Update build to 0.7.0.

This fixes the linux/gcc error building Google Test with gcc 4.7:

https://travis-ci.org/github/jbeder/yaml-cpp/jobs/668233706

.clang-format

@@ -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:        Cpp11
+IndentWidth:     2
+TabWidth:        8
+UseTab:          Never
+BreakBeforeBraces: Attach
+IndentFunctionDeclarationAfterType: true
+SpacesInParentheses: false
+SpacesInAngles:  false
+SpaceInEmptyParentheses: false
+SpacesInCStyleCastParentheses: false
+SpaceAfterControlStatementKeyword: true
+SpaceBeforeAssignmentOperators: true
+ContinuationIndentWidth: 4
+...
+

.codedocs

@@ -0,0 +1,50 @@
+# CodeDocs.xyz Configuration File
+
+# Optional project name, if left empty the GitHub repository name will be used.
+PROJECT_NAME =
+
+# One or more directories and files that contain example code to be included.
+EXAMPLE_PATH =
+
+# One or more directories and files to exclude from documentation generation.
+# Use relative paths with respect to the repository root directory.
+EXCLUDE = test/gtest-1.8.0/
+
+# One or more wildcard patterns to exclude files and directories from document
+# generation.
+EXCLUDE_PATTERNS =
+
+# One or more symbols to exclude from document generation. Symbols can be
+# namespaces, classes, or functions.
+EXCLUDE_SYMBOLS =
+
+# Override the default parser (language) used for each file extension.
+EXTENSION_MAPPING =
+
+# Set the wildcard patterns used to filter out the source-files.
+# If left blank the default is:
+# *.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl,
+# *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php,
+# *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, *.md, *.mm, *.dox, *.py,
+# *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, *.qsf, *.as and *.js.
+FILE_PATTERNS =
+
+# Hide undocumented class members.
+HIDE_UNDOC_MEMBERS =
+
+# Hide undocumented classes.
+HIDE_UNDOC_CLASSES =
+
+# Specify a markdown page whose contents should be used as the main page
+# (index.html). This will override a page marked as \mainpage. For example, a
+# README.md file usually serves as a useful main page.
+USE_MDFILE_AS_MAINPAGE = README.md
+
+# Specify external repository to link documentation with.
+# This is similar to Doxygen's TAGFILES option, but will automatically link to
+# tags of other repositories already using CodeDocs. List each repository to
+# link with by giving its location in the form of owner/repository.
+# For example:
+#   TAGLINKS = doxygen/doxygen CodeDocs/osg
+# Note: these repositories must already be built on CodeDocs.
+TAGLINKS =

.gitignore

@@ -0,0 +1,3 @@
+build/
+/tags
+/bazel-*

.hgeol

@@ -1,4 +0,0 @@
-**.h = native
-**.c = native
-**.cpp = native
-**.txt = native

.hgignore

@@ -1 +0,0 @@
-syntax: glob

.travis.yml

@@ -0,0 +1,37 @@
+language: c++
+
+matrix:
+  include:
+    - os: linux
+      compiler: gcc
+    - os: osx
+      compiler: clang
+    - os: osx
+      compiler: gcc
+env:
+  - CTEST_OUTPUT_ON_FAILURE=1
+
+before_script:
+  - mkdir build
+  - cd build
+  - cmake ..
+  - cd ..
+script:
+  - cmake --build build
+  - cmake --build build --target test
+
+addons:
+  apt:
+    sources:
+    - ubuntu-toolchain-r-test
+    - llvm-toolchain-precise-3.9
+    packages:
+    - g++-4.9
+    - clang-3.9
+    update: true
+  homebrew:
+    packages:
+    - ccache
+    - gcc@4.9
+    - llvm@4
+    update: true

BUILD.bazel

@@ -0,0 +1,14 @@
+cc_library(
+    name = "yaml-cpp_internal",
+    visibility = ["//:__subpackages__"],
+    strip_include_prefix = "src",
+    hdrs = glob(["src/**/*.h"]),
+)
+
+cc_library(
+    name = "yaml-cpp",
+    visibility = ["//visibility:public"],
+    includes = ["include"],
+    hdrs = glob(["include/**/*.h"]),
+    srcs = glob(["src/**/*.cpp", "src/**/*.h"]),
+)

CMakeLists.txt

@@ -1,285 +1,161 @@
-###
+# 3.5 is actually available almost everywhere, but this a good minimum
-### CMake settings
+cmake_minimum_required(VERSION 3.4)
-###
+project(YAML_CPP VERSION 0.7.0 LANGUAGES CXX)
-## Due to Mac OSX we need to keep compatibility with CMake 2.6
-# see http://www.cmake.org/Wiki/CMake_Policies
-cmake_minimum_required(VERSION 2.6)
-# see http://www.cmake.org/cmake/help/cmake-2-8-docs.html#policy:CMP0012
-if(POLICY CMP0012)
-	cmake_policy(SET CMP0012 OLD)
-endif()
-# see http://www.cmake.org/cmake/help/cmake-2-8-docs.html#policy:CMP0015
-if(POLICY CMP0015)
-	cmake_policy(SET CMP0015 OLD)
-endif()
 
+include(CMakePackageConfigHelpers)
+include(CMakeDependentOption)
 include(CheckCXXCompilerFlag)
+include(GNUInstallDirs)
+include(CTest)
 
+find_program(YAML_CPP_CLANG_FORMAT_EXE NAMES clang-format)
 
-###
+option(YAML_CPP_BUILD_CONTRIB "Enable yaml-cpp contrib in library" ON)
-### Project settings
+option(YAML_CPP_BUILD_TOOLS "Enable parse tools" ON)
-###
+option(YAML_BUILD_SHARED_LIBS "Build yaml-cpp shared library" ${BUILD_SHARED_LIBS})
-project(YAML_CPP)
 
-set(YAML_CPP_VERSION_MAJOR "0")
+cmake_dependent_option(YAML_CPP_BUILD_TESTS
-set(YAML_CPP_VERSION_MINOR "5")
+  "Enable yaml-cpp tests" ON
-set(YAML_CPP_VERSION_PATCH "0")
+  "BUILD_TESTING;CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR" OFF)
-set(YAML_CPP_VERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}.${YAML_CPP_VERSION_PATCH}")
+cmake_dependent_option(YAML_CPP_INSTALL
+  "Enable generation of yaml-cpp install targets" ON
+  "CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR" OFF)
+cmake_dependent_option(YAML_MSVC_SHARED_RT
+  "MSVC: Build yaml-cpp with shared runtime libs (/MD)" ON
+  "MSVC" OFF)
 
-enable_testing()
+set(yaml-cpp-type STATIC)
-
+set(yaml-cpp-label-postfix "static")
-
+if (YAML_BUILD_SHARED_LIBS)
-###
+  set(yaml-cpp-type SHARED)
-### Project options
+  set(yaml-cpp-label-postfix "shared")
-###
-## Project stuff
-option(YAML_CPP_BUILD_TOOLS "Enable testing and parse tools" ON)
-option(YAML_CPP_BUILD_CONTRIB "Enable contrib stuff in library" ON)
-
-## Build options
-# --> General
-# see http://www.cmake.org/cmake/help/cmake2.6docs.html#variable:BUILD_SHARED_LIBS
-#     http://www.cmake.org/cmake/help/cmake2.6docs.html#command:add_library
-option(BUILD_SHARED_LIBS "Build Shared Libraries" OFF)
-
-# --> Apple
-option(APPLE_UNIVERSAL_BIN "Apple: Build universal binary" OFF)
-
-# --> Microsoft Visual C++
-# see http://msdn.microsoft.com/en-us/library/aa278396(v=VS.60).aspx
-#     http://msdn.microsoft.com/en-us/library/2kzt1wy3(v=VS.71).aspx
-option(MSVC_SHARED_RT "MSVC: Build with shared runtime libs (/MD)" ON)
-option(MSVC_STHREADED_RT "MSVC: Build with single-threaded static runtime libs (/ML until VS .NET 2003)" OFF)
-
-###
-### Sources, headers, directories and libs
-###
-set(header_directory "include/yaml-cpp/")
-
-file(GLOB sources "src/[a-zA-Z]*.cpp")
-file(GLOB_RECURSE public_headers "include/yaml-cpp/[a-zA-Z]*.h")
-file(GLOB private_headers "src/[a-zA-Z]*.h")
-
-if(YAML_CPP_BUILD_CONTRIB)
-	file(GLOB contrib_sources "src/contrib/[a-zA-Z]*.cpp")
-	file(GLOB contrib_public_headers "include/yaml-cpp/contrib/[a-zA-Z]*.h")
-	file(GLOB contrib_private_headers "src/contrib/[a-zA-Z]*.h")
-else()
-	add_definitions(-DYAML_CPP_NO_CONTRIB)
 endif()
 
-if(VERBOSE)
+set(build-shared $<BOOL:${YAML_BUILD_SHARED_LIBS}>)
-	message(STATUS "sources: ${sources}")
+set(build-windows-dll $<AND:$<BOOL:${CMAKE_HOST_WIN32}>,${build-shared}>)
-	message(STATUS "public_headers: ${public_headers}")
+set(not-msvc $<NOT:$<CXX_COMPILER_ID:MSVC>>)
-	message(STATUS "private_headers: ${private_headers}")
+
-	message(STATUS "contrib_sources: ${contrib_sources}")
+if (NOT DEFINED CMAKE_MSVC_RUNTIME_LIBRARY)
-	message(STATUS "contrib_public_headers: ${contrib_public_headers}")
+  set(CMAKE_MSVC_RUNTIME_LIBRARY
-	message(STATUS "contrib_private_headers: ${contrib_private_headers}")
+    MultiThreaded$<$<CONFIG:Debug>:Debug>$<${build-shared}:DLL>)
 endif()
 
-include_directories(${YAML_CPP_SOURCE_DIR}/src)
+set(contrib-pattern "src/contrib/*.cpp")
-include_directories(${YAML_CPP_SOURCE_DIR}/include)
+set(src-pattern "src/*.cpp")
-
+if (CMAKE_VERSION VERSION_GREATER 3.12)
-find_package(Boost REQUIRED)
+  list(INSERT contrib-pattern 0 CONFIGURE_DEPENDS)
-include_directories(${Boost_INCLUDE_DIRS})
+  list(INSERT src-pattern 0 CONFIGURE_DEPENDS)
-
-
-###
-### General compilation settings
-###
-if(BUILD_SHARED_LIBS)
-	set(LABEL_SUFFIX "shared")
-else()
-	set(LABEL_SUFFIX "static")
 endif()
 
-if(APPLE)
+file(GLOB yaml-cpp-contrib-sources ${contrib-pattern})
-	if(APPLE_UNIVERSAL_BIN)
+file(GLOB yaml-cpp-sources ${src-pattern})
-		set(CMAKE_OSX_ARCHITECTURES ppc;i386)
+
-	endif()
+set(msvc-rt $<TARGET_PROPERTY:MSVC_RUNTIME_LIBRARY>)
+
+set(msvc-rt-mtd-static $<STREQUAL:${msvc-rt},MultiThreadedDebug>)
+set(msvc-rt-mt-static $<STREQUAL:${msvc-rt},MultiThreaded>)
+
+set(msvc-rt-mtd-dll $<STREQUAL:${msvc-rt},MultiThreadedDebugDLL>)
+set(msvc-rt-mt-dll $<STREQUAL:${msvc-rt},MultiThreadedDLL>)
+
+set(backport-msvc-runtime $<VERSION_LESS:${CMAKE_VERSION},3.15>)
+
+add_library(yaml-cpp ${yaml-cpp-type} "")
+add_library(yaml-cpp::yaml-cpp ALIAS yaml-cpp)
+
+set_property(TARGET yaml-cpp
+  PROPERTY
+    MSVC_RUNTIME_LIBRARY ${CMAKE_MSVC_RUNTIME_LIBRARY})
+set_property(TARGET yaml-cpp
+  PROPERTY
+    CXX_STANDARD_REQUIRED ON)
+
+target_include_directories(yaml-cpp
+  PUBLIC
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+  PRIVATE
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>)
+
+if (NOT DEFINED CMAKE_CXX_STANDARD)
+  set_target_properties(yaml-cpp
+    PROPERTIES
+      CXX_STANDARD 11)
 endif()
 
-if(IPHONE)
+target_compile_options(yaml-cpp
-	set(CMAKE_OSX_SYSROOT "iphoneos4.2")
+  PRIVATE
-	set(CMAKE_OSX_ARCHITECTURES "armv6;armv7")
+    $<${not-msvc}:-Wall -Wextra -Wshadow -Weffc++ -Wno-long-long>
-endif()
+    $<${not-msvc}:-pedantic -pedantic-errors>
 
-if(WIN32)
+    $<$<AND:${backport-msvc-runtime},${msvc-rt-mtd-static}>:-MTd>
-	if(BUILD_SHARED_LIBS)
+    $<$<AND:${backport-msvc-runtime},${msvc-rt-mt-static}>:-MT>
-		add_definitions(-D${PROJECT_NAME}_DLL)	# use or build Windows DLL
+    $<$<AND:${backport-msvc-runtime},${msvc-rt-mtd-dll}>:-MDd>
-	endif()
+    $<$<AND:${backport-msvc-runtime},${msvc-rt-mt-dll}>:-MD>
-	if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)
-		set(CMAKE_INSTALL_PREFIX "C:/")
-	endif()
-endif()
 
-# GCC specialities
+    # /wd4127 = disable warning C4127 "conditional expression is constant"
-if(CMAKE_COMPILER_IS_GNUCXX)
+    # http://msdn.microsoft.com/en-us/library/6t66728h.aspx
-	### General stuff
+    # /wd4355 = disable warning C4355 "'this' : used in base member initializer list
-	if(WIN32)
+    # http://msdn.microsoft.com/en-us/library/3c594ae3.aspx
-		set(CMAKE_SHARED_LIBRARY_PREFIX "")	# DLLs do not have a "lib" prefix
+    $<$<CXX_COMPILER_ID:MSVC>:/W3 /wd4127 /wd4355>)
-		set(CMAKE_IMPORT_LIBRARY_PREFIX "")	# same for DLL import libs
-		set(CMAKE_LINK_DEF_FILE_FLAG "")	# CMake workaround (2.8.3)
-	endif()
 
-	### Project stuff
+target_compile_definitions(yaml-cpp
-	if(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
+  PRIVATE
-		set(CMAKE_BUILD_TYPE Release)
+    $<${build-windows-dll}:${PROJECT_NAME}_DLL>
-	endif()
+    $<$<NOT:$<BOOL:${YAML_CPP_BUILD_CONTRIB}>>:YAML_CPP_NO_CONTRIB>)
-	#
-	set(CMAKE_CXX_FLAGS_RELEASE "-O2")
-	set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
-	set(CMAKE_CXX_FLAGS_DEBUG "-g")
-	set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os")
-	#
-	set(GCC_EXTRA_OPTIONS "")
-	#
-	set(FLAG_TESTED "-Wextra")
-	check_cxx_compiler_flag(${FLAG_TESTED} FLAG_WEXTRA)
-	if(FLAG_WEXTRA)
-		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)
-endif()
 
-# Microsoft VisualC++ specialities
+target_sources(yaml-cpp
-if(MSVC)
+  PRIVATE
-	### General stuff
+    $<$<BOOL:${YAML_CPP_BUILD_CONTRIB}>:${yaml-cpp-contrib-sources}>
-	# a) Change MSVC runtime library settings (/MD[d], /MT[d], /ML[d] (single-threaded until VS 2003))
+    ${yaml-cpp-sources})
-	#    plus set lib suffix for later use and project label accordingly
-	# see http://msdn.microsoft.com/en-us/library/aa278396(v=VS.60).aspx
-	#     http://msdn.microsoft.com/en-us/library/2kzt1wy3(v=VS.71).aspx
-	set(LIB_RT_SUFFIX "md")	# CMake defaults to /MD for MSVC
-	set(LIB_RT_OPTION "/MD")
-	#
-	if(NOT MSVC_SHARED_RT)	# User wants to have static runtime libraries (/MT, /ML)
-		if(MSVC_STHREADED_RT)	# User wants to have old single-threaded static runtime libraries
-			set(LIB_RT_SUFFIX "ml")
-			set(LIB_RT_OPTION "/ML")
-			if(NOT ${MSVC_VERSION} LESS 1400)
-				message(FATAL_ERROR "Single-threaded static runtime libraries (/ML) only available until VS .NET 2003 (7.1).")
-			endif()
-		else()
-			set(LIB_RT_SUFFIX "mt")
-			set(LIB_RT_OPTION "/MT")
-		endif()
-
-		# correct linker options
-		foreach(flag_var  CMAKE_C_FLAGS  CMAKE_CXX_FLAGS)
-			foreach(config_name  ""  DEBUG  RELEASE  MINSIZEREL  RELWITHDEBINFO)
-				set(var_name "${flag_var}")
-				if(NOT "${config_name}" STREQUAL "")
-					set(var_name "${var_name}_${config_name}")
-				endif()
-				string(REPLACE "/MD" "${LIB_RT_OPTION}" ${var_name} "${${var_name}}")
-			endforeach()
-		endforeach()
-	endif()
-	#
-	set(LABEL_SUFFIX "${LABEL_SUFFIX} ${LIB_RT_SUFFIX}")
-
-	# b) Change prefix for static libraries
-	set(CMAKE_STATIC_LIBRARY_PREFIX "lib")	# to distinguish static libraries from DLL import libs
-
-	# c) Correct suffixes for static libraries
-	if(NOT BUILD_SHARED_LIBS)
-		### General stuff
-		set(LIB_TARGET_SUFFIX "${LIB_SUFFIX}${LIB_RT_SUFFIX}")
-	endif()
-
-	### Project stuff
-	# /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}")
-endif()
-
-
-###
-### General install settings
-###
-if(WIN32)
-	set(_library_dir bin)	# .dll are in PATH, like executables
-else()
-	set(_library_dir lib)
-endif()
-
-set(INCLUDE_INSTALL_ROOT_DIR include)
-
-set(INCLUDE_INSTALL_DIR ${INCLUDE_INSTALL_ROOT_DIR}/yaml-cpp)
-set(LIB_INSTALL_DIR "${_library_dir}${LIB_SUFFIX}")
-
-set(_INSTALL_DESTINATIONS
-	RUNTIME DESTINATION bin
-	LIBRARY DESTINATION ${LIB_INSTALL_DIR}
-	ARCHIVE DESTINATION "lib${LIB_SUFFIX}"
-)
-
-
-###
-### Library
-###
-add_library(yaml-cpp
-	${sources}
-	${public_headers}
-	${private_headers}
-	${contrib_sources}
-	${contrib_public_headers}
-	${contrib_private_headers}
-)
 
 set_target_properties(yaml-cpp PROPERTIES
-	VERSION "${YAML_CPP_VERSION}"
+  VERSION "${PROJECT_VERSION}"
-	SOVERSION "${YAML_CPP_VERSION_MAJOR}.${YAML_CPP_VERSION_MINOR}"
+  SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}"
-	PROJECT_LABEL "yaml-cpp ${LABEL_SUFFIX}"
+  PROJECT_LABEL "yaml-cpp ${yaml-cpp-label-postfix}"
-)
+  DEBUG_POSTFIX d)
 
-if(IPHONE)
+configure_package_config_file(
-	set_target_properties(yaml-cpp PROPERTIES
+  "${PROJECT_SOURCE_DIR}/yaml-cpp-config.cmake.in"
-		XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET "3.0"
+  "${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake"
-	)
+  INSTALL_DESTINATION "${CMAKE_INSTALL_DATADIR}/cmake/yaml-cpp")
+
+write_basic_package_version_file(
+  "${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake"
+  COMPATIBILITY AnyNewerVersion)
+
+configure_file(yaml-cpp.pc.in yaml-cpp.pc @ONLY)
+
+if (YAML_CPP_INSTALL)
+	install(TARGETS yaml-cpp
+    EXPORT yaml-cpp-targets
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+	install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+		FILES_MATCHING PATTERN "*.h")
+  install(EXPORT yaml-cpp-targets
+    DESTINATION "${CMAKE_INSTALL_DATADIR}/cmake/yaml-cpp")
+	install(FILES
+		"${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake"
+		"${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake"
+    DESTINATION "${CMAKE_INSTALL_DATADIR}/cmake/yaml-cpp")
+  install(FILES "${PROJECT_BINARY_DIR}/yaml-cpp.pc"
+    DESTINATION ${CMAKE_INSTALL_DATADIR}/pkgconfig)
 endif()
 
-if(MSVC)
+if(YAML_CPP_BUILD_TESTS)
-	if(NOT BUILD_SHARED_LIBS)
-		# correct library names
-		set_target_properties(yaml-cpp PROPERTIES
-			DEBUG_POSTFIX "${LIB_TARGET_SUFFIX}d"
-			RELEASE_POSTFIX "${LIB_TARGET_SUFFIX}"
-			MINSIZEREL_POSTFIX "${LIB_TARGET_SUFFIX}"
-			RELWITHDEBINFO_POSTFIX "${LIB_TARGET_SUFFIX}"
-		)
-	endif()
-endif()
-
-install(TARGETS yaml-cpp ${_INSTALL_DESTINATIONS})
-install(
-	DIRECTORY ${header_directory}
-	DESTINATION ${INCLUDE_INSTALL_DIR}
-	FILES_MATCHING PATTERN "*.h"
-)
-
-if(UNIX)
-	set(PC_FILE ${CMAKE_BINARY_DIR}/yaml-cpp.pc)
-	configure_file("yaml-cpp.pc.cmake" ${PC_FILE} @ONLY)
-	install(FILES ${PC_FILE} DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
-endif()
-
-
-###
-### Extras
-###
-if(YAML_CPP_BUILD_TOOLS)
 	add_subdirectory(test)
+endif()
+
+if(YAML_CPP_BUILD_TOOLS)
 	add_subdirectory(util)
 endif()
+
+if (YAML_CPP_CLANG_FORMAT_EXE)
+  add_custom_target(format
+    COMMAND clang-format --style=file -i $<TARGET_PROPERTY:yaml-cpp,SOURCES>
+    COMMENT "Running clang-format"
+    VERBATIM)
+endif()

CONTRIBUTING.md

@@ -0,0 +1,26 @@
+# Style
+
+This project is formatted with [clang-format][fmt] using the style file at the root of the repository. Please run clang-format before sending a pull request.
+
+In general, try to follow the style of surrounding code. We mostly follow the [Google C++ style guide][cpp-style].
+
+Commit messages should be in the imperative mood, as described in the [Git contributing file][git-contrib]:
+
+> Describe your changes in imperative mood, e.g. "make xyzzy do frotz"
+> instead of "[This patch] makes xyzzy do frotz" or "[I] changed xyzzy
+> to do frotz", as if you are giving orders to the codebase to change
+> its behaviour.
+
+[fmt]: http://clang.llvm.org/docs/ClangFormat.html
+[cpp-style]: https://google.github.io/styleguide/cppguide.html
+[git-contrib]: http://git.kernel.org/cgit/git/git.git/tree/Documentation/SubmittingPatches?id=HEAD
+
+# Tests
+
+Please verify the tests pass by running the target `tests/run_tests`.
+
+If you are adding functionality, add tests accordingly.
+
+# Pull request process
+
+Every pull request undergoes a code review. Unfortunately, github's code review process isn't great, but we'll manage. During the code review, if you make changes, add new commits to the pull request for each change. Once the code review is complete, rebase against the master branch and squash into a single commit.

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Jesse Beder.
+Copyright (c) 2008-2015 Jesse Beder.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -0,0 +1,55 @@
+# yaml-cpp [![Build Status](https://travis-ci.org/jbeder/yaml-cpp.svg?branch=master)](https://travis-ci.org/jbeder/yaml-cpp) [![Documentation](https://codedocs.xyz/jbeder/yaml-cpp.svg)](https://codedocs.xyz/jbeder/yaml-cpp/)
+
+yaml-cpp is a [YAML](http://www.yaml.org/) parser and emitter in C++ matching the [YAML 1.2 spec](http://www.yaml.org/spec/1.2/spec.html).
+
+To get a feel for how it can be used, see the [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial) or [How to Emit YAML](https://github.com/jbeder/yaml-cpp/wiki/How-To-Emit-YAML). For the old API (version < 0.5.0), see [How To Parse A Document](https://github.com/jbeder/yaml-cpp/wiki/How-To-Parse-A-Document-(Old-API)).
+
+# Problems? #
+
+If you find a bug, post an [issue](https://github.com/jbeder/yaml-cpp/issues)! If you have questions about how to use yaml-cpp, please post it on http://stackoverflow.com and tag it [`yaml-cpp`](http://stackoverflow.com/questions/tagged/yaml-cpp).
+
+# How to Build #
+
+yaml-cpp uses [CMake](http://www.cmake.org) to support cross-platform building. The basic steps to build are:
+
+1. Download and install [CMake](http://www.cmake.org) (Resources -> Download).
+
+**Note:** If you don't use the provided installer for your platform, make sure that you add CMake's bin folder to your path.
+
+2. Navigate into the source directory, and type:
+
+```
+mkdir build
+cd build
+```
+
+3. Run CMake. The basic syntax is:
+
+```
+cmake [-G generator] [-DYAML_BUILD_SHARED_LIBS=ON|OFF] ..
+```
+
+  * The `generator` is whatever type of build system you'd like to use. To see a full list of generators on your platform, just run `cmake` (with no arguments). For example:
+    * On Windows, you might use "Visual Studio 12 2013" to generate a Visual Studio 2013 solution or "Visual Studio 14 2015 Win64" to generate a 64-bit Visual Studio 2015 solution.
+    * On OS X, you might use "Xcode" to generate an Xcode project
+    * On a UNIX-y system, simply omit the option to generate a makefile
+
+  * yaml-cpp defaults to building a static library, but you may build a shared library by specifying `-DYAML_BUILD_SHARED_LIBS=ON`.
+
+  * For more options on customizing the build, see the [CMakeLists.txt](https://github.com/jbeder/yaml-cpp/blob/master/CMakeLists.txt) file.
+
+4. Build it!
+
+5. To clean up, just remove the `build` directory.
+
+# Recent Release #
+
+[yaml-cpp 0.6.0](https://github.com/jbeder/yaml-cpp/releases/tag/yaml-cpp-0.6.0) has been released! This release requires C++11, and no longer depends on Boost.
+
+[yaml-cpp 0.3.0](https://github.com/jbeder/yaml-cpp/releases/tag/release-0.3.0) is still available if you want the old API.
+
+**The old API will continue to be supported, and will still receive bugfixes!** The 0.3.x and 0.4.x versions will be old API releases, and 0.5.x and above will all be new API releases.
+
+# API Documentation 
+
+The autogenerated API reference is hosted on [CodeDocs](https://codedocs.xyz/jbeder/yaml-cpp/index.html)

WORKSPACE

@@ -0,0 +1,10 @@
+workspace(name = "com_github_jbeder_yaml_cpp")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+    name = "com_google_googletest",
+    strip_prefix = "googletest-release-1.8.1",
+    url = "https://github.com/google/googletest/archive/release-1.8.1.tar.gz",
+    sha256 = "9bf1fe5182a604b4135edc1a425ae356c9ad15e9b23f9f12a02e80184c3a249c",
+)

include/yaml-cpp/anchor.h

@@ -1,15 +1,16 @@
 #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
+namespace YAML {
-{
+using anchor_t = std::size_t;
-	typedef std::size_t anchor_t;
 const anchor_t NullAnchor = 0;
 }
 

include/yaml-cpp/binary.h

@@ -1,34 +1,45 @@
 #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
+#include "yaml-cpp/dll.h"
-{
-    std::string EncodeBase64(const unsigned char *data, std::size_t size);
-    std::vector<unsigned char> DecodeBase64(const std::string& input);
 
-    class Binary {
+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_)
-        Binary(const unsigned char *data_, std::size_t size_): m_unownedData(data_), m_unownedSize(size_) {}
+      : m_data{}, m_unownedData(data_), m_unownedSize(size_) {}
+  Binary() : Binary(nullptr, 0) {}
+  Binary(const Binary &) = default;
+  Binary(Binary &&) = default;
+  Binary &operator=(const Binary &) = default;
+  Binary &operator=(Binary &&) = default;
 
   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; }
+  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]);
+      std::copy(m_unownedData, m_unownedData + m_unownedSize, rhs.begin());
-                m_unownedData = 0;
+      m_unownedData = nullptr;
       m_unownedSize = 0;
     } else {
       m_data.swap(rhs);
@@ -48,15 +59,13 @@ namespace YAML
     return true;
   }
 
-        bool operator != (const Binary& rhs) const {
+  bool operator!=(const Binary &rhs) const { return !(*this == rhs); }
-            return !(*this == rhs);
-        }
 
  private:
   std::vector<unsigned char> m_data;
   const unsigned char *m_unownedData;
   std::size_t m_unownedSize;
 };
-}
+}  // namespace YAML
 
 #endif  // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/contrib/anchordict.h

@@ -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,30 @@
 
 #include "../anchor.h"
 
-namespace YAML
+namespace YAML {
-{
+/**
-  /// AnchorDict
+ * An object that stores and retrieves values correlating to {@link anchor_t}
-  /// . An object that stores and retrieves values correlating to anchor_t
+ * values.
-  ///   values.
+ *
-  /// . Efficient implementation that can make assumptions about how anchor_t
+ * <p>Efficient implementation that can make assumptions about how
-  ///   values are assigned by the Parser class.
+ * {@code anchor_t} values are assigned by the {@link Parser} class.
+ */
 template <class T>
-  class AnchorDict
+class AnchorDict {
-  {
  public:
-    void Register(anchor_t anchor, T value)
+  AnchorDict() : m_data{} {}
-    {
+  void Register(anchor_t anchor, T value) {
-      if (anchor > m_data.size())
+    if (anchor > m_data.size()) {
-      {
       m_data.resize(anchor);
     }
     m_data[anchor - 1] = value;
   }
 
-    T Get(anchor_t anchor) const
+  T Get(anchor_t anchor) const { return m_data[anchor - 1]; }
-    {
-      return m_data[anchor - 1];
-    }
 
  private:
   std::vector<T> m_data;
 };
-}
+}  // namespace YAML
 
 #endif  // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/contrib/graphbuilder.h

@@ -1,49 +1,61 @@
 #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
+namespace YAML {
-{
 class Parser;
 
 // GraphBuilderInterface
 // . Abstraction of node creation
-  // . pParentNode is always NULL or the return value of one of the NewXXX()
+// . pParentNode is always nullptr or the return value of one of the NewXXX()
 //   functions.
-  class GraphBuilderInterface
+class GraphBuilderInterface {
-  {
  public:
+  virtual ~GraphBuilderInterface() = 0;
+
   // 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;
+  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;
+  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;
+  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;}
+  virtual void *AnchorReference(const Mark &mark, void *pNode) {
+    (void)mark;
+    return pNode;
+  }
 };
 
 // Typesafe wrapper for GraphBuilderInterface.  Assumes that Impl defines
@@ -54,18 +66,16 @@ namespace YAML
 // prototypes changed to accept an explicit Node*, Sequence*, or Map* where
 // appropriate.
 template <class Impl>
-  class GraphBuilder : public GraphBuilderInterface
+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)
+  GraphBuilder(Impl &impl) : m_impl(impl) {
-    {
+    Map *pMap = nullptr;
-      Map* pMap = NULL;
+    Sequence *pSeq = nullptr;
-      Sequence* pSeq = NULL;
+    Node *pNode = nullptr;
-      Node* pNode = NULL;
 
     // Type consistency checks
     pNode = pMap;
@@ -78,12 +88,16 @@ namespace YAML
     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) {
+  virtual void *NewScalar(const Mark &mark, const std::string &tag,
-      return CheckType<Node>(m_impl.NewScalar(mark, tag, AsNode(pParentNode), value));
+                          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) {
+  virtual void *NewSequence(const Mark &mark, const std::string &tag,
-      return CheckType<Sequence>(m_impl.NewSequence(mark, tag, AsNode(pParentNode)));
+                            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));
@@ -92,15 +106,14 @@ namespace YAML
     m_impl.SequenceComplete(AsSequence(pSequence));
   }
 
-    virtual void *NewMap(const Mark& mark, const std::string& tag, void *pParentNode) {
+  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) {
+  virtual void MapComplete(void *pMap) { m_impl.MapComplete(AsMap(pMap)); }
-      m_impl.MapComplete(AsMap(pMap));
-    }
 
   virtual void *AnchorReference(const Mark &mark, void *pNode) {
     return CheckType<Node>(m_impl.AnchorReference(mark, AsNode(pNode)));
@@ -111,22 +124,25 @@ namespace YAML
 
   // Static check for pointer to T
   template <class T, class U>
-    static T* CheckType(U* p) {return p;}
+  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 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);
+void *BuildGraphOfNextDocument(Parser &parser,
+                               GraphBuilderInterface &graphBuilder);
 
 template <class Impl>
-  typename Impl::Node *BuildGraphOfNextDocument(Parser& parser, Impl& impl)
+typename Impl::Node *BuildGraphOfNextDocument(Parser &parser, Impl &impl) {
-  {
   GraphBuilder<Impl> graphBuilder(impl);
-    return static_cast<typename Impl::Node *>(BuildGraphOfNextDocument(
+  return static_cast<typename Impl::Node *>(
-      parser, graphBuilder
+      BuildGraphOfNextDocument(parser, graphBuilder));
-    ));
 }
 }
 

include/yaml-cpp/dll.h

@@ -1,20 +1,25 @@
 #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
+// The following ifdef block is the standard way of creating macros which make
-// from a DLL simpler. All files within this DLL are compiled with the yaml_cpp_EXPORTS
+// exporting from a DLL simpler. All files within this DLL are compiled with the
-// symbol defined on the command line. this symbol should not be defined on any project
+// yaml_cpp_EXPORTS symbol defined on the command line. This symbol should not
-// that uses this DLL. This way any other project whose source files include this file see
+// be defined on any project that uses this DLL. This way any other project
-// YAML_CPP_API functions as being imported from a DLL, whereas this DLL sees symbols
+// whose source files include this file see YAML_CPP_API functions as being
-// defined with this macro as being exported.
+// 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_DLL      // Using or Building YAML-CPP DLL (definition defined
-	#ifdef yaml_cpp_EXPORTS // Building YAML-CPP DLL (definition created by CMake or defined manually)
+                         // 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

include/yaml-cpp/emitfromevents.h

@@ -1,34 +1,44 @@
 #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
+#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
+class EmitFromEvents : public EventHandler {
-	{
  public:
   EmitFromEvents(Emitter& emitter);
 
-		virtual void OnDocumentStart(const Mark& mark);
+  void OnDocumentStart(const Mark& mark) override;
-		virtual void OnDocumentEnd();
+  void OnDocumentEnd() override;
 
-		virtual void OnNull(const Mark& mark, anchor_t anchor);
+  void OnNull(const Mark& mark, anchor_t anchor) override;
-		virtual void OnAlias(const Mark& mark, anchor_t anchor);
+  void OnAlias(const Mark& mark, anchor_t anchor) override;
-		virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value);
+  void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value) override;
 
-		virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+  void OnSequenceStart(const Mark& mark, const std::string& tag,
-		virtual void OnSequenceEnd();
+                               anchor_t anchor, EmitterStyle::value style) override;
+  void OnSequenceEnd() override;
 
-		virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+  void OnMapStart(const Mark& mark, const std::string& tag,
-		virtual void OnMapEnd();
+                          anchor_t anchor, EmitterStyle::value style) override;
+  void OnMapEnd() override;
 
  private:
   void BeginNode();
@@ -37,7 +47,9 @@ namespace YAML
  private:
   Emitter& m_emitter;
 
-		struct State { enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue }; };
+  struct State {
+    enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue };
+  };
   std::stack<State::value> m_stateStack;
 };
 }

include/yaml-cpp/emitter.h

@@ -1,31 +1,41 @@
 #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 <cmath>
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <type_traits>
 
-#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
+namespace YAML {
-{
+class Binary;
+struct _Null;
+}  // namespace YAML
+
+namespace YAML {
 class EmitterState;
 
-	class YAML_CPP_API Emitter: private noncopyable
+class YAML_CPP_API Emitter {
-	{
  public:
   Emitter();
   explicit Emitter(std::ostream& stream);
+  Emitter(const Emitter&) = delete;
+  Emitter& operator=(const Emitter&) = delete;
   ~Emitter();
 
   // output
@@ -43,11 +53,11 @@ namespace YAML
   bool SetIntBase(EMITTER_MANIP value);
   bool SetSeqFormat(EMITTER_MANIP value);
   bool SetMapFormat(EMITTER_MANIP value);
-		bool SetIndent(unsigned n);
+  bool SetIndent(std::size_t n);
-		bool SetPreCommentIndent(unsigned n);
+  bool SetPreCommentIndent(std::size_t n);
-		bool SetPostCommentIndent(unsigned n);
+  bool SetPostCommentIndent(std::size_t n);
-        bool SetFloatPrecision(unsigned n);
+  bool SetFloatPrecision(std::size_t n);
-        bool SetDoublePrecision(unsigned n);
+  bool SetDoublePrecision(std::size_t n);
 
   // local setters
   Emitter& SetLocalValue(EMITTER_MANIP value);
@@ -72,9 +82,10 @@ namespace YAML
   Emitter& WriteStreamable(T value);
 
  private:
-        template<typename T> void SetStreamablePrecision(std::stringstream&) {}
+  template <typename T>
-        unsigned GetFloatPrecision() const;
+  void SetStreamablePrecision(std::stringstream&) {}
-        unsigned GetDoublePrecision() const;
+  std::size_t GetFloatPrecision() const;
+  std::size_t GetDoublePrecision() const;
 
   void PrepareIntegralStream(std::stringstream& stream) const;
   void StartedScalar();
@@ -109,19 +120,18 @@ namespace YAML
   void BlockMapPrepareSimpleKey(EmitterNodeType::value child);
   void BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child);
 
-        void SpaceOrIndentTo(bool requireSpace, unsigned indent);
+  void SpaceOrIndentTo(bool requireSpace, std::size_t indent);
 
   const char* ComputeFullBoolName(bool b) const;
   bool CanEmitNewline() const;
 
  private:
-		std::auto_ptr<EmitterState> m_pState;
+  std::unique_ptr<EmitterState> m_pState;
   ostream_wrapper m_stream;
 };
 
 template <typename T>
-	inline Emitter& Emitter::WriteIntegralType(T value)
+inline Emitter& Emitter::WriteIntegralType(T value) {
-	{
   if (!good())
     return *this;
 
@@ -138,8 +148,7 @@ namespace YAML
 }
 
 template <typename T>
-	inline Emitter& Emitter::WriteStreamable(T value)
+inline Emitter& Emitter::WriteStreamable(T value) {
-	{
   if (!good())
     return *this;
 
@@ -147,7 +156,27 @@ namespace YAML
 
   std::stringstream stream;
   SetStreamablePrecision<T>(stream);
+
+  bool special = false;
+  if (std::is_floating_point<T>::value) {
+    if ((std::numeric_limits<T>::has_quiet_NaN ||
+         std::numeric_limits<T>::has_signaling_NaN) &&
+        std::isnan(value)) {
+      special = true;
+      stream << ".nan";
+    } else if (std::numeric_limits<T>::has_infinity && std::isinf(value)) {
+      special = true;
+      if (std::signbit(value)) {
+        stream << "-.inf";
+      } else {
+        stream << ".inf";
+      }
+    }
+  }
+
+  if (!special) {
     stream << value;
+  }
   m_stream << stream.str();
 
   StartedScalar();
@@ -156,42 +185,82 @@ namespace YAML
 }
 
 template <>
-    inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream)
+inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream) {
-    {
+  stream.precision(static_cast<std::streamsize>(GetFloatPrecision()));
-		stream.precision(GetFloatPrecision());
 }
 
 template <>
-    inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream)
+inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream) {
-    {
+  stream.precision(static_cast<std::streamsize>(GetDoublePrecision()));
-		stream.precision(GetDoublePrecision());
 }
 
 // overloads of insertion
-	inline Emitter& operator << (Emitter& emitter, const std::string& v) { return emitter.Write(v); }
+inline Emitter& operator<<(Emitter& emitter, const std::string& v) {
-	inline Emitter& operator << (Emitter& emitter, bool v) { return emitter.Write(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, bool v) {
-	inline Emitter& operator << (Emitter& emitter, const _Alias& v) { return emitter.Write(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, char v) {
-	inline Emitter& operator << (Emitter& emitter, const _Comment& v) { return emitter.Write(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, 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, 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, int v) {
-	inline Emitter& operator << (Emitter& emitter, unsigned int v) { return emitter.WriteIntegralType(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, unsigned int v) {
-	inline Emitter& operator << (Emitter& emitter, long v) { return emitter.WriteIntegralType(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, short v) {
-	inline Emitter& operator << (Emitter& emitter, unsigned long long v) { return emitter.WriteIntegralType(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, float v) {
-	inline Emitter& operator << (Emitter& emitter, double v) { return emitter.WriteStreamable(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);
@@ -204,6 +273,6 @@ namespace YAML
 inline Emitter& operator<<(Emitter& emitter, _Precision precision) {
   return emitter.SetLocalPrecision(precision);
 }
-}
+}  // namespace YAML
 
 #endif  // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/emitterdef.h

@@ -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
+namespace YAML {
-{
+struct EmitterNodeType {
-    struct EmitterNodeType { enum value { None, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap }; };
+  enum value { NoType, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap };
+};
 }
 
 #endif  // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/emittermanip.h

@@ -1,15 +1,15 @@
 #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
+namespace YAML {
-{
 enum EMITTER_MANIP {
   // general manipulators
   Auto,
@@ -67,45 +67,40 @@ namespace YAML
   int value;
 };
 
-	inline _Indent Indent(int value) {
+inline _Indent Indent(int value) { return _Indent(value); }
-		return _Indent(value);
-	}
 
 struct _Alias {
   _Alias(const std::string& content_) : content(content_) {}
   std::string content;
 };
 
-	inline _Alias Alias(const std::string content) {
+inline _Alias Alias(const std::string& content) { return _Alias(content); }
-		return _Alias(content);
-	}
 
 struct _Anchor {
   _Anchor(const std::string& content_) : content(content_) {}
   std::string content;
 };
 
-	inline _Anchor Anchor(const std::string content) {
+inline _Anchor Anchor(const std::string& content) { return _Anchor(content); }
-		return _Anchor(content);
-	}
 
 struct _Tag {
-		struct Type { enum value { Verbatim, PrimaryHandle, NamedHandle }; };
+  struct Type {
+    enum value { Verbatim, PrimaryHandle, NamedHandle };
+  };
 
-		explicit _Tag(const std::string& prefix_, const std::string& content_, Type::value type_)
+  explicit _Tag(const std::string& prefix_, const std::string& content_,
-		: prefix(prefix_), content(content_), type(type_)
+                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) {
+inline _Tag VerbatimTag(const std::string& content) {
   return _Tag("", content, _Tag::Type::Verbatim);
 }
 
-	inline _Tag LocalTag(const std::string content) {
+inline _Tag LocalTag(const std::string& content) {
   return _Tag("", content, _Tag::Type::PrimaryHandle);
 }
 
@@ -113,7 +108,7 @@ namespace YAML
   return _Tag(prefix, content, _Tag::Type::NamedHandle);
 }
 
-	inline _Tag SecondaryTag(const std::string content) {
+inline _Tag SecondaryTag(const std::string& content) {
   return _Tag("", content, _Tag::Type::NamedHandle);
 }
 
@@ -122,28 +117,21 @@ namespace YAML
   std::string content;
 };
 
-	inline _Comment Comment(const std::string content) {
+inline _Comment Comment(const std::string& content) { return _Comment(content); }
-		return _Comment(content);
-	}
 
 struct _Precision {
-        _Precision(int floatPrecision_, int doublePrecision_): floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {}
+  _Precision(int floatPrecision_, int doublePrecision_)
+      : floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {}
 
   int floatPrecision;
   int doublePrecision;
 };
 
-    inline _Precision FloatPrecision(int n) {
+inline _Precision FloatPrecision(int n) { return _Precision(n, -1); }
-        return _Precision(n, -1);
-    }
 
-    inline _Precision DoublePrecision(int n) {
+inline _Precision DoublePrecision(int n) { return _Precision(-1, n); }
-        return _Precision(-1, n);
-    }
 
-    inline _Precision Precision(int n) {
+inline _Precision Precision(int n) { return _Precision(n, n); }
-        return _Precision(n, n);
-    }
 }
 
 #endif  // EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/emitterstyle.h

@@ -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

include/yaml-cpp/eventhandler.h

@@ -1,36 +1,45 @@
 #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
+#include "yaml-cpp/anchor.h"
-{
+#include "yaml-cpp/emitterstyle.h"
+
+namespace YAML {
 struct Mark;
 
-	class EventHandler
+class EventHandler {
-	{
  public:
-		virtual ~EventHandler() {}
+  virtual ~EventHandler() = default;
 
   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 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) = 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) = 0;
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor, EmitterStyle::value style) = 0;
   virtual void OnMapEnd() = 0;
-	};
+
+  virtual void OnAnchor(const Mark& /*mark*/,
+                        const std::string& /*anchor_name*/) {
+    // empty default implementation for compatibility
   }
+};
+}  // namespace YAML
 
 #endif  // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

include/yaml-cpp/exceptions.h

@@ -1,39 +1,46 @@
 #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/noexcept.h"
 #include "yaml-cpp/traits.h"
+#include <sstream>
 #include <stdexcept>
 #include <string>
-#include <sstream>
 
-namespace YAML
+namespace YAML {
-{
 // error messages
-	namespace ErrorMsg
+namespace ErrorMsg {
-	{
+const char* const YAML_DIRECTIVE_ARGS =
-		const char * const YAML_DIRECTIVE_ARGS    = "YAML directives must have exactly one argument";
+    "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 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 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_TAGS =
-		const char * const MULTIPLE_ANCHORS       = "cannot assign multiple anchors to the same node";
+    "cannot assign multiple tags to the same node";
-		const char * const MULTIPLE_ALIASES       = "cannot assign multiple aliases to the same node";
+const char* const MULTIPLE_ANCHORS =
-		const char * const ALIAS_CONTENT          = "aliases can't have any content, *including* tags";
+    "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: ";
@@ -41,20 +48,28 @@ namespace YAML
 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 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_ALIAS =
-		const char * const CHAR_IN_ANCHOR         = "illegal character found while scanning anchor";
+    "illegal character found while scanning alias";
-		const char * const ZERO_INDENT_IN_BLOCK   = "cannot set zero indentation for a block scalar";
+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 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_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";
@@ -66,14 +81,16 @@ namespace YAML
 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 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";
 
 template <typename T>
-		inline const std::string KEY_NOT_FOUND_WITH_KEY(const T&, typename disable_if<is_numeric<T> >::type * = 0) {
+inline const std::string KEY_NOT_FOUND_WITH_KEY(
+    const T&, typename disable_if<is_numeric<T>>::type* = 0) {
   return KEY_NOT_FOUND;
 }
 
@@ -84,117 +101,189 @@ namespace YAML
 }
 
 template <typename T>
-		inline const std::string KEY_NOT_FOUND_WITH_KEY(const T& key, typename enable_if<is_numeric<T> >::type * = 0) {
+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();
 }
+
+template <typename T>
+inline const std::string BAD_SUBSCRIPT_WITH_KEY(
+    const T&, typename disable_if<is_numeric<T>>::type* = nullptr) {
+  return BAD_SUBSCRIPT;
 }
 
-	class Exception: public std::runtime_error {
+inline const std::string BAD_SUBSCRIPT_WITH_KEY(const std::string& key) {
+  std::stringstream stream;
+  stream << BAD_SUBSCRIPT << " (key: \"" << key << "\")";
+  return stream.str();
+}
+
+template <typename T>
+inline const std::string BAD_SUBSCRIPT_WITH_KEY(
+    const T& key, typename enable_if<is_numeric<T>>::type* = nullptr) {
+  std::stringstream stream;
+  stream << BAD_SUBSCRIPT << " (key: \"" << key << "\")";
+  return stream.str();
+}
+
+inline const std::string INVALID_NODE_WITH_KEY(const std::string& key) {
+  std::stringstream stream;
+  if (key.empty()) {
+    return INVALID_NODE;
+  }
+  stream << "invalid node; first invalid key: \"" << key << "\"";
+  return stream.str();
+}
+}
+
+class YAML_CPP_API 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() {}
+  ~Exception() YAML_CPP_NOEXCEPT override;
+
+  Exception(const Exception&) = default;
 
   Mark mark;
   std::string msg;
 
  private:
-		static const std::string build_what(const Mark& mark, const std::string& msg) {
+  static const std::string build_what(const Mark& mark,
+                                      const std::string& msg) {
+    if (mark.is_null()) {
+      return msg;
+    }
+
     std::stringstream output;
-			output << "yaml-cpp: error at line " << mark.line+1 << ", column " << mark.column+1 << ": " << msg;
+    output << "yaml-cpp: error at line " << mark.line + 1 << ", column "
+           << mark.column + 1 << ": " << msg;
     return output.str();
   }
 };
 
-	class ParserException: public Exception {
+class YAML_CPP_API ParserException : public Exception {
  public:
   ParserException(const Mark& mark_, const std::string& msg_)
       : Exception(mark_, msg_) {}
+  ParserException(const ParserException&) = default;
+  ~ParserException() YAML_CPP_NOEXCEPT override;
 };
 
-	class RepresentationException: public Exception {
+class YAML_CPP_API RepresentationException : public Exception {
  public:
   RepresentationException(const Mark& mark_, const std::string& msg_)
       : Exception(mark_, msg_) {}
+  RepresentationException(const RepresentationException&) = default;
+  ~RepresentationException() YAML_CPP_NOEXCEPT override;
 };
 
 // representation exceptions
-	class InvalidScalar: public RepresentationException {
+class YAML_CPP_API InvalidScalar : public RepresentationException {
  public:
   InvalidScalar(const Mark& mark_)
       : RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {}
+  InvalidScalar(const InvalidScalar&) = default;
+  ~InvalidScalar() YAML_CPP_NOEXCEPT override;
 };
 
-	class KeyNotFound: public RepresentationException {
+class YAML_CPP_API KeyNotFound : public RepresentationException {
  public:
   template <typename T>
   KeyNotFound(const Mark& mark_, const T& key_)
-			: RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {}
+      : RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {
+  }
+  KeyNotFound(const KeyNotFound&) = default;
+  ~KeyNotFound() YAML_CPP_NOEXCEPT override;
 };
 
 template <typename T>
-	class TypedKeyNotFound: public KeyNotFound {
+class YAML_CPP_API TypedKeyNotFound : public KeyNotFound {
  public:
   TypedKeyNotFound(const Mark& mark_, const T& key_)
       : KeyNotFound(mark_, key_), key(key_) {}
-		virtual ~TypedKeyNotFound() throw() {}
+  ~TypedKeyNotFound() YAML_CPP_NOEXCEPT override = default;
 
   T key;
 };
 
 template <typename T>
-	inline TypedKeyNotFound <T> MakeTypedKeyNotFound(const Mark& mark, const T& key) {
+inline TypedKeyNotFound<T> MakeTypedKeyNotFound(const Mark& mark,
+                                                const T& key) {
   return TypedKeyNotFound<T>(mark, key);
 }
 
-	class BadConversion: public RepresentationException {
+class YAML_CPP_API InvalidNode : public RepresentationException {
  public:
-		BadConversion()
+  InvalidNode(const std::string& key)
-        : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_CONVERSION) {}
+      : RepresentationException(Mark::null_mark(),
+                                ErrorMsg::INVALID_NODE_WITH_KEY(key)) {}
+  InvalidNode(const InvalidNode&) = default;
+  ~InvalidNode() YAML_CPP_NOEXCEPT override;
+};
+
+class YAML_CPP_API BadConversion : public RepresentationException {
+ public:
+  explicit BadConversion(const Mark& mark_)
+      : RepresentationException(mark_, ErrorMsg::BAD_CONVERSION) {}
+  BadConversion(const BadConversion&) = default;
+  ~BadConversion() YAML_CPP_NOEXCEPT override;
 };
 
 template <typename T>
 class TypedBadConversion : public BadConversion {
  public:
-		TypedBadConversion()
+  explicit TypedBadConversion(const Mark& mark_) : BadConversion(mark_) {}
-        : BadConversion() {}
 };
 
-	class BadDereference: public RepresentationException {
+class YAML_CPP_API BadDereference : public RepresentationException {
  public:
   BadDereference()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {}
+  BadDereference(const BadDereference&) = default;
+  ~BadDereference() YAML_CPP_NOEXCEPT override;
 };
 
-	class BadSubscript: public RepresentationException {
+class YAML_CPP_API BadSubscript : public RepresentationException {
  public:
-		BadSubscript()
+  template <typename Key>
-		: RepresentationException(Mark::null_mark(), ErrorMsg::BAD_SUBSCRIPT) {}
+  BadSubscript(const Mark& mark_, const Key& key)
+      : RepresentationException(mark_,
+                                ErrorMsg::BAD_SUBSCRIPT_WITH_KEY(key)) {}
+  BadSubscript(const BadSubscript&) = default;
+  ~BadSubscript() YAML_CPP_NOEXCEPT override;
 };
 
-	class BadPushback: public RepresentationException {
+class YAML_CPP_API BadPushback : public RepresentationException {
  public:
   BadPushback()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {}
+  BadPushback(const BadPushback&) = default;
+  ~BadPushback() YAML_CPP_NOEXCEPT override;
 };
 
-	class BadInsert: public RepresentationException {
+class YAML_CPP_API BadInsert : public RepresentationException {
  public:
   BadInsert()
       : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {}
+  BadInsert(const BadInsert&) = default;
+  ~BadInsert() YAML_CPP_NOEXCEPT override;
 };
 
-	class EmitterException: public Exception {
+class YAML_CPP_API EmitterException : public Exception {
  public:
   EmitterException(const std::string& msg_)
       : Exception(Mark::null_mark(), msg_) {}
+  EmitterException(const EmitterException&) = default;
+  ~EmitterException() YAML_CPP_NOEXCEPT override;
 };
 
-    class BadFile: public Exception {
+class YAML_CPP_API BadFile : public Exception {
  public:
   BadFile() : Exception(Mark::null_mark(), ErrorMsg::BAD_FILE) {}
+  BadFile(const BadFile&) = default;
+  ~BadFile() YAML_CPP_NOEXCEPT override;
 };
 }
 

include/yaml-cpp/mark.h

@@ -1,25 +1,28 @@
 #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
+namespace YAML {
-{
 struct YAML_CPP_API Mark {
   Mark() : pos(0), line(0), column(0) {}
 
   static const Mark null_mark() { return Mark(-1, -1, -1); }
 
+  bool is_null() const { return pos == -1 && line == -1 && column == -1; }
+
   int pos;
   int line, column;
 
  private:
-		Mark(int pos_, int line_, int column_): pos(pos_), line(line_), column(column_) {}
+  Mark(int pos_, int line_, int column_)
+      : pos(pos_), line(line_), column(column_) {}
 };
 }
 

include/yaml-cpp/node/convert.h

@@ -1,26 +1,41 @@
 #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 <array>
-#include "yaml-cpp/binary.h"
+#include <cmath>
-#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 <type_traits>
 #include <vector>
 
-namespace YAML
+#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"
+
+
+namespace YAML {
+class Binary;
+struct _Null;
+template <typename T>
+struct convert;
+}  // namespace YAML
+
+namespace YAML {
 namespace conversion {
 inline bool IsInfinity(const std::string& input) {
-            return input == ".inf" || input == ".Inf" || input == ".INF" || input == "+.inf" || input == "+.Inf" || input == "+.INF";
+  return input == ".inf" || input == ".Inf" || input == ".INF" ||
+         input == "+.inf" || input == "+.Inf" || input == "+.INF";
 }
 
 inline bool IsNegativeInfinity(const std::string& input) {
@@ -32,12 +47,21 @@ namespace YAML
 }
 }
 
+// Node
+template <>
+struct convert<Node> {
+  static Node encode(const Node& rhs) { return rhs; }
+
+  static bool decode(const Node& node, Node& rhs) {
+    rhs.reset(node);
+    return true;
+  }
+};
+
 // std::string
 template <>
 struct convert<std::string> {
-		static Node encode(const std::string& rhs) {
+  static Node encode(const std::string& rhs) { return Node(rhs); }
-			return Node(rhs);
-		}
 
   static bool decode(const Node& node, std::string& rhs) {
     if (!node.IsScalar())
@@ -47,79 +71,125 @@ namespace YAML
   }
 };
 
+// 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 */) {
+  static Node encode(const _Null& /* rhs */) { return Node(); }
-			return Node();
-		}
 
   static bool decode(const Node& node, _Null& /* rhs */) {
     return node.IsNull();
   }
 };
 
-#define YAML_DEFINE_CONVERT_STREAMABLE(type)\
+namespace conversion {
+template <typename T>
+typename std::enable_if< std::is_floating_point<T>::value, void>::type
+inner_encode(const T& rhs, std::stringstream& stream){
+  if (std::isnan(rhs)) {
+    stream << ".nan";
+  } else if (std::isinf(rhs)) {
+    if (std::signbit(rhs)) {
+      stream << "-.inf";
+    } else {
+      stream << ".inf";
+    }
+  } else {
+    stream << rhs;
+  }
+}
+
+template <typename T>
+typename std::enable_if<!std::is_floating_point<T>::value, void>::type
+inner_encode(const T& rhs, std::stringstream& stream){
+  stream << rhs;
+}
+}
+
+#define YAML_DEFINE_CONVERT_STREAMABLE(type, negative_op)                  \
   template <>                                                              \
   struct convert<type> {                                                   \
+                                                                           \
     static Node encode(const type& rhs) {                                  \
       std::stringstream stream;                                            \
-			stream << rhs;\
+      stream.precision(std::numeric_limits<type>::max_digits10);           \
+      conversion::inner_encode(rhs, stream);                               \
       return Node(stream.str());                                           \
     }                                                                      \
                                                                            \
     static bool decode(const Node& node, type& rhs) {                      \
-			if(node.Type() != NodeType::Scalar)\
+      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())\
+      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 = -std::numeric_limits<type>::infinity();\
+          rhs = negative_op std::numeric_limits<type>::infinity();         \
           return true;                                                     \
         }                                                                  \
       }                                                                    \
                                                                            \
-            if(std::numeric_limits<type>::has_quiet_NaN && conversion::IsNaN(input)) {\
+      if (std::numeric_limits<type>::has_quiet_NaN) {                      \
+        if (conversion::IsNaN(input)) {                                    \
           rhs = std::numeric_limits<type>::quiet_NaN();                    \
           return true;                                                     \
+        }                                                                  \
       }                                                                    \
                                                                            \
       return false;                                                        \
     }                                                                      \
   }
 
-	YAML_DEFINE_CONVERT_STREAMABLE(int);
+#define YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(type) \
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned);
+  YAML_DEFINE_CONVERT_STREAMABLE(type, -)
-	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);
+#define YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(type) \
-	YAML_DEFINE_CONVERT_STREAMABLE(unsigned char);
+  YAML_DEFINE_CONVERT_STREAMABLE(type, +)
 
-	YAML_DEFINE_CONVERT_STREAMABLE(float);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(int);
-	YAML_DEFINE_CONVERT_STREAMABLE(double);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(short);
-	YAML_DEFINE_CONVERT_STREAMABLE(long double);
+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) {
+  static Node encode(bool rhs) { return rhs ? Node("true") : Node("false"); }
-			return rhs ? Node("true") : Node("false");
-		}
 
-		static bool decode(const Node& node, bool& rhs);
+  YAML_CPP_API static bool decode(const Node& node, bool& rhs);
 };
 
 // std::map
@@ -127,7 +197,8 @@ namespace YAML
 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)
+    for (typename std::map<K, V>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
       node.force_insert(it->first, it->second);
     return node;
   }
@@ -153,7 +224,8 @@ namespace YAML
 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)
+    for (typename std::vector<T>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
       node.push_back(*it);
     return node;
   }
@@ -179,7 +251,8 @@ namespace YAML
 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)
+    for (typename std::list<T>::const_iterator it = rhs.begin();
+         it != rhs.end(); ++it)
       node.push_back(*it);
     return node;
   }
@@ -200,6 +273,71 @@ namespace YAML
   }
 };
 
+// std::array
+template <typename T, std::size_t N>
+struct convert<std::array<T, N>> {
+  static Node encode(const std::array<T, N>& rhs) {
+    Node node(NodeType::Sequence);
+    for (const auto& element : rhs) {
+      node.push_back(element);
+    }
+    return node;
+  }
+
+  static bool decode(const Node& node, std::array<T, N>& rhs) {
+    if (!isNodeValid(node)) {
+      return false;
+    }
+
+    for (auto i = 0u; i < node.size(); ++i) {
+#if defined(__GNUC__) && __GNUC__ < 4
+      // workaround for GCC 3:
+      rhs[i] = node[i].template as<T>();
+#else
+      rhs[i] = node[i].as<T>();
+#endif
+    }
+    return true;
+  }
+
+ private:
+  static bool isNodeValid(const Node& node) {
+    return node.IsSequence() && node.size() == N;
+  }
+};
+
+// 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> {

include/yaml-cpp/node/detail/bool_type.h

@@ -1,26 +0,0 @@
-#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
-#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*);
-	}
-}
-
-#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

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

@@ -1,35 +1,39 @@
 #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>
+#include <type_traits>
 
-namespace YAML
+namespace YAML {
-{
+namespace detail {
-	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 */) {
+  static node* get(const std::vector<node*>& /* sequence */,
-				return 0;
+                   const Key& /* key */, shared_memory_holder /* pMemory */) {
+    return nullptr;
   }
 };
 
 template <typename Key>
-		struct get_idx<Key, typename boost::enable_if<boost::is_unsigned<Key> >::type> {
+struct get_idx<Key,
-			static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder /* pMemory */) {
+               typename std::enable_if<std::is_unsigned<Key>::value &&
-				return key < sequence.size() ? sequence[key] : 0;
+                                       !std::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] : nullptr;
   }
 
-			static node *get(std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) {
+  static node* get(std::vector<node*>& sequence, const Key& key,
-				if(key > sequence.size())
+                   shared_memory_holder pMemory) {
-					return 0;
+    if (key > sequence.size() || (key > 0 && !sequence[key - 1]->is_defined()))
+      return nullptr;
     if (key == sequence.size())
       sequence.push_back(&pMemory->create_node());
     return sequence[key];
@@ -37,44 +41,101 @@ namespace YAML
 };
 
 template <typename Key>
-		struct get_idx<Key, typename boost::enable_if<boost::is_signed<Key> >::type> {
+struct get_idx<Key, typename std::enable_if<std::is_signed<Key>::value>::type> {
-			static node *get(const std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) {
+  static node* get(const std::vector<node*>& sequence, const Key& key,
-				return key >= 0 ? get_idx<std::size_t>::get(sequence, static_cast<std::size_t>(key), pMemory) : 0;
+                   shared_memory_holder pMemory) {
+    return key >= 0 ? get_idx<std::size_t>::get(
+                          sequence, static_cast<std::size_t>(key), pMemory)
+                    : nullptr;
   }
-			static node *get(std::vector<node *>& sequence, const Key& key, shared_memory_holder pMemory) {
+  static node* get(std::vector<node*>& sequence, const Key& key,
-				return key >= 0 ? get_idx<std::size_t>::get(sequence, static_cast<std::size_t>(key), pMemory) : 0;
+                   shared_memory_holder pMemory) {
+    return key >= 0 ? get_idx<std::size_t>::get(
+                          sequence, static_cast<std::size_t>(key), pMemory)
+                    : nullptr;
   }
 };
 
+template <typename Key, typename Enable = void>
+struct remove_idx {
+  static bool remove(std::vector<node*>&, const Key&, std::size_t&) {
+    return false;
+  }
+};
+
+template <typename Key>
+struct remove_idx<
+    Key, typename std::enable_if<std::is_unsigned<Key>::value &&
+                                 !std::is_same<Key, bool>::value>::type> {
+
+  static bool remove(std::vector<node*>& sequence, const Key& key,
+                     std::size_t& seqSize) {
+    if (key >= sequence.size()) {
+      return false;
+    } else {
+      sequence.erase(sequence.begin() + key);
+      if (seqSize > key) {
+          --seqSize;
+      }
+      return true;
+    }
+  }
+};
+
+template <typename Key>
+struct remove_idx<Key,
+                  typename std::enable_if<std::is_signed<Key>::value>::type> {
+
+  static bool remove(std::vector<node*>& sequence, const Key& key,
+                     std::size_t& seqSize) {
+    return key >= 0 ? remove_idx<std::size_t>::remove(
+                          sequence, static_cast<std::size_t>(key), seqSize)
+                    : false;
+  }
+};
+
+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;
+}
+
+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
+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();
+      return nullptr;
     case NodeType::Sequence:
       if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory))
-						return *pNode;
+        return pNode;
-					return pMemory->create_node();
+      return nullptr;
     case NodeType::Scalar:
-                    throw BadSubscript();
+      throw BadSubscript(m_mark, key);
   }
 
   for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-				if(equals(*it->first, key, pMemory))
+    if (it->first->equals(key, pMemory)) {
-					return *it->second;
+      return it->second;
+    }
   }
 
-			return pMemory->create_node();
+  return nullptr;
 }
 
 template <typename Key>
-		inline node& node_data::get(const Key& key, shared_memory_holder pMemory)
+inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
-		{
   switch (m_type) {
     case NodeType::Map:
       break;
@@ -89,13 +150,14 @@ namespace YAML
       convert_to_map(pMemory);
       break;
     case NodeType::Scalar:
-                    throw BadSubscript();
+      throw BadSubscript(m_mark, key);
   }
 
   for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
-				if(equals(*it->first, key, pMemory))
+    if (it->first->equals(key, pMemory)) {
       return *it->second;
     }
+  }
 
   node& k = convert_to_node(key, pMemory);
   node& v = pMemory->create_node();
@@ -104,25 +166,34 @@ namespace YAML
 }
 
 template <typename Key>
-		inline bool node_data::remove(const Key& key, shared_memory_holder pMemory)
+inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) {
-		{
+  if (m_type == NodeType::Sequence) {
-			if(m_type != NodeType::Map)
+    return remove_idx<Key>::remove(m_sequence, key, m_seqSize);
-				return false;
+  } else if (m_type == NodeType::Map) {
+    kv_pairs::iterator it = m_undefinedPairs.begin();
+    while (it != m_undefinedPairs.end()) {
+      kv_pairs::iterator jt = std::next(it);
+      if (it->first->equals(key, pMemory)) {
+        m_undefinedPairs.erase(it);
+      }
+      it = jt;
+    }
 
-			for(node_map::iterator it=m_map.begin();it!=m_map.end();++it) {
+    for (node_map::iterator iter = m_map.begin(); iter != m_map.end(); ++iter) {
-				if(equals(*it->first, key, pMemory)) {
+      if (iter->first->equals(key, pMemory)) {
-					m_map.erase(it);
+        m_map.erase(iter);
         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)
+inline void node_data::force_insert(const Key& key, const Value& value,
-        {
+                                    shared_memory_holder pMemory) {
   switch (m_type) {
     case NodeType::Map:
       break;
@@ -141,17 +212,8 @@ namespace YAML
 }
 
 template <typename T>
-		inline bool node_data::equals(node& node, const T& rhs, shared_memory_holder pMemory)
+inline node& node_data::convert_to_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);

include/yaml-cpp/node/detail/iterator.h

@@ -1,53 +1,82 @@
 #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 "yaml-cpp/node/node.h"
-#include <boost/utility.hpp>
+#include "yaml-cpp/node/ptr.h"
+#include <cstddef>
+#include <iterator>
 
-namespace YAML
+
-{
+namespace YAML {
-	namespace detail
+namespace detail {
-	{
 struct iterator_value;
 
 template <typename V>
-		class iterator_base: public boost::iterator_adaptor<
+class iterator_base {
-		iterator_base<V>,
+
-		node_iterator,
-		V,
-		std::forward_iterator_tag,
-		V>
-		{
  private:
-			template<typename> friend class iterator_base;
+  template <typename>
+  friend class iterator_base;
   struct enabler {};
-			typedef typename iterator_base::base_type base_type;
+  using base_type = node_iterator;
+
+  struct proxy {
+    explicit proxy(const V& x) : m_ref(x) {}
+    V* operator->() { return std::addressof(m_ref); }
+    operator V*() { return std::addressof(m_ref); }
+
+    V m_ref;
+  };
 
  public:
-			typedef typename iterator_base::value_type value_type;
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = V;
+  using difference_type = std::ptrdiff_t;
+  using pointer = V*;
+  using reference = V;
 
  public:
-			iterator_base() {}
+  iterator_base() : m_iterator(), m_pMemory() {}
-			explicit iterator_base(base_type rhs, shared_memory_holder pMemory): iterator_base::iterator_adaptor_(rhs), m_pMemory(pMemory) {}
+  explicit iterator_base(base_type rhs, shared_memory_holder pMemory)
+      : m_iterator(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) {}
+  iterator_base(const iterator_base<W>& rhs,
+                typename std::enable_if<std::is_convertible<W*, V*>::value,
+                                        enabler>::type = enabler())
+      : m_iterator(rhs.m_iterator), m_pMemory(rhs.m_pMemory) {}
 
-		private:
+  iterator_base<V>& operator++() {
-			friend class boost::iterator_core_access;
+    ++m_iterator;
+    return *this;
+  }
 
-			void increment() { this->base_reference() = boost::next(this->base()); }
+  iterator_base<V> operator++(int) {
+    iterator_base<V> iterator_pre(*this);
+    ++(*this);
+    return iterator_pre;
+  }
 
-			value_type dereference() const {
+  template <typename W>
-				const typename base_type::value_type& v = *this->base();
+  bool operator==(const iterator_base<W>& rhs) const {
+    return m_iterator == rhs.m_iterator;
+  }
+
+  template <typename W>
+  bool operator!=(const iterator_base<W>& rhs) const {
+    return m_iterator != rhs.m_iterator;
+  }
+
+  value_type operator*() const {
+    const typename base_type::value_type& v = *m_iterator;
     if (v.pNode)
       return value_type(Node(*v, m_pMemory));
     if (v.first && v.second)
@@ -55,10 +84,13 @@ namespace YAML
     return value_type();
   }
 
+  proxy operator->() const { return proxy(**this); }
+
  private:
+  base_type m_iterator;
   shared_memory_holder m_pMemory;
 };
-	}
+}  // namespace detail
-}
+}  // namespace YAML
 
 #endif  // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node/detail/iterator_fwd.h

@@ -1,27 +1,27 @@
 #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
+namespace YAML {
-{
-	class node;
 
 namespace detail {
 struct iterator_value;
-		template<typename V> class iterator_base;
+template <typename V>
+class iterator_base;
 }
 
-	typedef detail::iterator_base<detail::iterator_value> iterator;
+using iterator = detail::iterator_base<detail::iterator_value>;
-	typedef detail::iterator_base<const detail::iterator_value> const_iterator;
+using const_iterator = detail::iterator_base<const detail::iterator_value>;
 }
 
 #endif  // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node/detail/memory.h

@@ -1,29 +1,37 @@
 #ifndef VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define VALUE_DETAIL_MEMORY_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/ptr.h"
 #include <set>
-#include <boost/shared_ptr.hpp>
 
-namespace YAML
+#include "yaml-cpp/dll.h"
-{
+#include "yaml-cpp/node/ptr.h"
-	namespace detail
+
-	{
+namespace YAML {
-		class memory {
+namespace detail {
+class node;
+}  // namespace detail
+}  // namespace YAML
+
+namespace YAML {
+namespace detail {
+class YAML_CPP_API memory {
  public:
+  memory() : m_nodes{} {}
   node& create_node();
   void merge(const memory& rhs);
 
  private:
-			typedef std::set<shared_node> Nodes;
+  using Nodes = std::set<shared_node>;
   Nodes m_nodes;
 };
 
-		class memory_holder {
+class YAML_CPP_API memory_holder {
  public:
   memory_holder() : m_pMemory(new memory) {}
 
@@ -31,9 +39,9 @@ namespace YAML
   void merge(memory_holder& rhs);
 
  private:
-			boost::shared_ptr<memory> m_pMemory;
+  shared_memory m_pMemory;
 };
-	}
+}  // namespace detail
-}
+}  // namespace YAML
 
 #endif  // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node/detail/node.h

@@ -1,43 +1,55 @@
 #ifndef NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NODE_DETAIL_NODE_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/type.h"
+#include "yaml-cpp/emitterstyle.h"
-#include "yaml-cpp/node/ptr.h"
 #include "yaml-cpp/node/detail/node_ref.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/type.h"
 #include <set>
-#include <boost/utility.hpp>
+#include <atomic>
+
+namespace YAML {
+namespace detail {
+class node {
+ private:
+  struct less {
+    bool operator ()(const node* l, const node* r) {return l->m_index < r->m_index;}
+  };
 
-namespace YAML
-{
-	namespace detail
-	{
-		class node: private boost::noncopyable
-		{
  public:
-			node(): m_pRef(new node_ref) {}
+  node() : m_pRef(new node_ref), m_dependencies{} {}
+  node(const node&) = delete;
+  node& operator=(const node&) = delete;
 
   bool is(const node& rhs) const { return m_pRef == rhs.m_pRef; }
   const node_ref* ref() const { return m_pRef.get(); }
 
   bool is_defined() const { return m_pRef->is_defined(); }
+  const Mark& mark() const { return m_pRef->mark(); }
   NodeType::value type() const { return m_pRef->type(); }
 
   const std::string& scalar() const { return m_pRef->scalar(); }
   const std::string& tag() const { return m_pRef->tag(); }
+  EmitterStyle::value style() const { return m_pRef->style(); }
+
+  template <typename T>
+  bool equals(const T& rhs, shared_memory_holder pMemory);
+  bool equals(const char* rhs, shared_memory_holder pMemory);
 
   void mark_defined() {
     if (is_defined())
       return;
 
     m_pRef->mark_defined();
-				for(nodes::iterator it=m_dependencies.begin();it!=m_dependencies.end();++it)
+    for (node* dependency : m_dependencies)
-					(*it)->mark_defined();
+      dependency->mark_defined();
     m_dependencies.clear();
   }
 
@@ -59,6 +71,8 @@ namespace YAML
     m_pRef->set_data(*rhs.m_pRef);
   }
 
+  void set_mark(const Mark& mark) { m_pRef->set_mark(mark); }
+
   void set_type(NodeType::value type) {
     if (type != NodeType::Undefined)
       mark_defined();
@@ -77,19 +91,30 @@ namespace YAML
     m_pRef->set_tag(tag);
   }
 
+  // style
+  void set_style(EmitterStyle::value style) {
+    mark_defined();
+    m_pRef->set_style(style);
+  }
+
   // size/iterator
   std::size_t size() const { return m_pRef->size(); }
 
-			const_node_iterator begin() const { return static_cast<const node_ref&>(*m_pRef).begin(); }
+  const_node_iterator begin() const {
+    return static_cast<const node_ref&>(*m_pRef).begin();
+  }
   node_iterator begin() { return m_pRef->begin(); }
 
-			const_node_iterator end() const { return static_cast<const node_ref&>(*m_pRef).end(); }
+  const_node_iterator end() const {
+    return static_cast<const node_ref&>(*m_pRef).end();
+  }
   node_iterator end() { return m_pRef->end(); }
 
   // sequence
-			void push_back(node& node, shared_memory_holder pMemory) {
+  void push_back(node& input, shared_memory_holder pMemory) {
-				m_pRef->push_back(node, pMemory);
+    m_pRef->push_back(input, pMemory);
-				node.add_dependency(*this);
+    input.add_dependency(*this);
+    m_index = m_amount.fetch_add(1);
   }
   void insert(node& key, node& value, shared_memory_holder pMemory) {
     m_pRef->insert(key, value, pMemory);
@@ -98,33 +123,55 @@ namespace YAML
   }
 
   // indexing
-			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const { return static_cast<const node_ref&>(*m_pRef).get(key, pMemory); }
+  template <typename Key>
-			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) {
+  node* get(const Key& key, shared_memory_holder pMemory) const {
+    // NOTE: this returns a non-const node so that the top-level Node can wrap
+    // it, and returns a pointer so that it can be nullptr (if there is no such
+    // key).
+    return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
+  }
+  template <typename Key>
+  node& get(const Key& key, shared_memory_holder pMemory) {
     node& value = m_pRef->get(key, pMemory);
     value.add_dependency(*this);
     return value;
   }
-			template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory) { return m_pRef->remove(key, pMemory); }
+  template <typename Key>
+  bool remove(const Key& key, shared_memory_holder pMemory) {
+    return m_pRef->remove(key, pMemory);
+  }
 
-			node& get(node& key, shared_memory_holder pMemory) const { return static_cast<const node_ref&>(*m_pRef).get(key, pMemory); }
+  node* get(node& key, shared_memory_holder pMemory) const {
+    // NOTE: this returns a non-const node so that the top-level Node can wrap
+    // it, and returns a pointer so that it can be nullptr (if there is no such
+    // key).
+    return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
+  }
   node& get(node& key, shared_memory_holder pMemory) {
     node& value = m_pRef->get(key, pMemory);
     key.add_dependency(*this);
     value.add_dependency(*this);
     return value;
   }
-			bool remove(node& key, shared_memory_holder pMemory) { return m_pRef->remove(key, pMemory); }
+  bool remove(node& key, shared_memory_holder pMemory) {
+    return m_pRef->remove(key, pMemory);
+  }
 
   // map
   template <typename Key, typename Value>
-            void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory){ m_pRef->force_insert(key, value, pMemory); }
+  void force_insert(const Key& key, const Value& value,
+                    shared_memory_holder pMemory) {
+    m_pRef->force_insert(key, value, pMemory);
+  }
 
  private:
   shared_node_ref m_pRef;
-			typedef std::set<node *> nodes;
+  using nodes = std::set<node*, less>;
   nodes m_dependencies;
+  size_t m_index;
+  static std::atomic<size_t> m_amount;
 };
-	}
+}  // namespace detail
-}
+}  // namespace YAML
 
 #endif  // NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node/detail/node_data.h

@@ -1,39 +1,54 @@
 #ifndef VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define VALUE_DETAIL_NODE_DATA_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/iterator.h"
-#include "yaml-cpp/node/ptr.h"
-#include "yaml-cpp/node/type.h"
-#include <boost/utility.hpp>
 #include <list>
+#include <map>
+#include <string>
 #include <utility>
 #include <vector>
 
-namespace YAML
+#include "yaml-cpp/dll.h"
-{
+#include "yaml-cpp/node/detail/node_iterator.h"
-	namespace detail
+#include "yaml-cpp/node/iterator.h"
-	{
+#include "yaml-cpp/node/ptr.h"
-		class node_data: private boost::noncopyable
+#include "yaml-cpp/node/type.h"
-		{
+
+namespace YAML {
+namespace detail {
+class node;
+}  // namespace detail
+}  // namespace YAML
+
+namespace YAML {
+namespace detail {
+class YAML_CPP_API node_data {
  public:
   node_data();
+  node_data(const node_data&) = delete;
+  node_data& operator=(const node_data&) = delete;
 
   void mark_defined();
+  void set_mark(const Mark& mark);
   void set_type(NodeType::value type);
   void set_tag(const std::string& tag);
   void set_null();
   void set_scalar(const std::string& scalar);
+  void set_style(EmitterStyle::value style);
 
   bool is_defined() const { return m_isDefined; }
-			NodeType::value type() const { return m_isDefined ? m_type : NodeType::Undefined; }
+  const Mark& mark() const { return m_mark; }
+  NodeType::value type() const {
+    return m_isDefined ? m_type : NodeType::Undefined;
+  }
   const std::string& scalar() const { return m_scalar; }
   const std::string& tag() const { return m_tag; }
+  EmitterStyle::value style() const { return m_style; }
 
   // size/iterator
   std::size_t size() const;
@@ -49,20 +64,24 @@ namespace YAML
   void insert(node& key, node& value, shared_memory_holder pMemory);
 
   // indexing
-			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const;
+  template <typename Key>
-			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory);
+  node* get(const Key& key, shared_memory_holder pMemory) const;
-			template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory);
+  template <typename Key>
+  node& get(const Key& key, shared_memory_holder pMemory);
+  template <typename Key>
+  bool remove(const Key& key, shared_memory_holder pMemory);
 
-			node& get(node& key, shared_memory_holder pMemory) const;
+  node* get(node& key, shared_memory_holder pMemory) const;
   node& get(node& key, shared_memory_holder pMemory);
   bool remove(node& key, shared_memory_holder pMemory);
 
   // map
   template <typename Key, typename Value>
-            void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory);
+  void force_insert(const Key& key, const Value& value,
+                    shared_memory_holder pMemory);
 
  public:
-			static std::string empty_scalar;
+  static const std::string& empty_scalar();
 
  private:
   void compute_seq_size() const;
@@ -75,32 +94,31 @@ namespace YAML
   void convert_to_map(shared_memory_holder pMemory);
   void convert_sequence_to_map(shared_memory_holder pMemory);
 
-			template<typename T>
-			static bool equals(node& node, const T& rhs, shared_memory_holder pMemory);
-			
   template <typename T>
   static node& convert_to_node(const T& rhs, shared_memory_holder pMemory);
 
  private:
   bool m_isDefined;
+  Mark m_mark;
   NodeType::value m_type;
   std::string m_tag;
+  EmitterStyle::value m_style;
 
   // scalar
   std::string m_scalar;
 
   // sequence
-			typedef std::vector<node *> node_seq;
+  using node_seq = std::vector<node *>;
   node_seq m_sequence;
 
   mutable std::size_t m_seqSize;
 
   // map
-			typedef std::map<node *, node *> node_map;
+  using node_map = std::vector<std::pair<node*, node*>>;
   node_map m_map;
 
-			typedef std::pair<node *, node *> kv_pair;
+  using kv_pair = std::pair<node*, node*>;
-			typedef std::list<kv_pair> kv_pairs;
+  using kv_pairs = std::list<kv_pair>;
   mutable kv_pairs m_undefinedPairs;
 };
 }

include/yaml-cpp/node/detail/node_iterator.h

@@ -1,32 +1,34 @@
 #ifndef VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define VALUE_DETAIL_NODE_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 <boost/iterator/iterator_facade.hpp>
+#include <cstddef>
-#include <boost/utility/enable_if.hpp>
+#include <iterator>
+#include <memory>
 #include <map>
 #include <utility>
 #include <vector>
 
-namespace YAML
+namespace YAML {
-{
+namespace detail {
-	namespace detail
+struct iterator_type {
-	{
+  enum value { NoneType, Sequence, Map };
-		struct iterator_type { enum value { None, Sequence, Map }; };
+};
 
 template <typename V>
 struct node_iterator_value : public std::pair<V*, V*> {
-			typedef std::pair<V*, V*> kv;
+  using kv = std::pair<V*, V*>;
 
-			node_iterator_value(): kv(), pNode(0) {}
+  node_iterator_value() : kv(), pNode(nullptr) {}
   explicit node_iterator_value(V& rhs) : kv(), pNode(&rhs) {}
-			explicit node_iterator_value(V& key, V& value): kv(&key, &value), pNode(0) {}
+  explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(nullptr) {}
 
   V& operator*() const { return *pNode; }
   V& operator->() const { return *pNode; }
@@ -34,67 +36,95 @@ namespace YAML
   V* pNode;
 };
 
-		typedef std::vector<node *> node_seq;
+using node_seq = std::vector<node *>;
-		typedef std::map<node *, node *> node_map;
+using node_map = std::vector<std::pair<node*, node*>>;
 
 template <typename V>
 struct node_iterator_type {
-			typedef node_seq::iterator seq;
+  using seq = node_seq::iterator;
-			typedef node_map::iterator map;
+  using map = node_map::iterator;
 };
 
 template <typename V>
 struct node_iterator_type<const V> {
-			typedef node_seq::const_iterator seq;
+  using seq = node_seq::const_iterator;
-			typedef node_map::const_iterator map;
+  using map = node_map::const_iterator;
 };
 
-
 template <typename V>
-		class node_iterator_base: public boost::iterator_facade<
+class node_iterator_base {
-		node_iterator_base<V>,
-		node_iterator_value<V>,
-		std::forward_iterator_tag,
-		node_iterator_value<V> >
-		{
  private:
   struct enabler {};
 
-		public:
+  struct proxy {
-			typedef typename node_iterator_type<V>::seq SeqIter;
+    explicit proxy(const node_iterator_value<V>& x) : m_ref(x) {}
-			typedef typename node_iterator_type<V>::map MapIter;
+    node_iterator_value<V>* operator->() { return std::addressof(m_ref); }
-			typedef node_iterator_value<V> value_type;
+    operator node_iterator_value<V>*() { return std::addressof(m_ref); }
 
-			node_iterator_base(): m_type(iterator_type::None) {}
+    node_iterator_value<V> m_ref;
-			explicit node_iterator_base(SeqIter seqIt): m_type(iterator_type::Sequence), m_seqIt(seqIt) {}
+  };
-			explicit node_iterator_base(MapIter mapIt, MapIter mapEnd): m_type(iterator_type::Map), m_mapIt(mapIt), m_mapEnd(mapEnd) {
+
+ public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = node_iterator_value<V>;
+  using difference_type = std::ptrdiff_t;
+  using pointer = node_iterator_value<V>*;
+  using reference = node_iterator_value<V>;
+  using SeqIter = typename node_iterator_type<V>::seq;
+  using MapIter = typename node_iterator_type<V>::map;
+
+  node_iterator_base()
+      : m_type(iterator_type::NoneType), m_seqIt(), m_mapIt(), m_mapEnd() {}
+  explicit node_iterator_base(SeqIter seqIt)
+      : m_type(iterator_type::Sequence),
+        m_seqIt(seqIt),
+        m_mapIt(),
+        m_mapEnd() {}
+  explicit node_iterator_base(MapIter mapIt, MapIter mapEnd)
+      : m_type(iterator_type::Map),
+        m_seqIt(),
+        m_mapIt(mapIt),
+        m_mapEnd(mapEnd) {
     m_mapIt = increment_until_defined(m_mapIt);
   }
 
   template <typename W>
-			node_iterator_base(const node_iterator_base<W>& rhs, typename boost::enable_if<boost::is_convertible<W*, V*>, enabler>::type = enabler())
+  node_iterator_base(const node_iterator_base<W>& rhs,
-			: m_type(rhs.m_type), m_seqIt(rhs.m_seqIt), m_mapIt(rhs.m_mapIt), m_mapEnd(rhs.m_mapEnd) {}
+                     typename std::enable_if<std::is_convertible<W*, V*>::value,
+                                             enabler>::type = enabler())
+      : m_type(rhs.m_type),
+        m_seqIt(rhs.m_seqIt),
+        m_mapIt(rhs.m_mapIt),
+        m_mapEnd(rhs.m_mapEnd) {}
 
-		private:
+  template <typename>
-			friend class boost::iterator_core_access;
+  friend class node_iterator_base;
-			template<typename> friend class node_iterator_base;
 
   template <typename W>
-			bool equal(const node_iterator_base<W>& rhs) const {
+  bool operator==(const node_iterator_base<W>& rhs) const {
     if (m_type != rhs.m_type)
       return false;
 
     switch (m_type) {
-					case iterator_type::None: return true;
+      case iterator_type::NoneType:
-					case iterator_type::Sequence: return m_seqIt == rhs.m_seqIt;
+        return true;
-					case iterator_type::Map: return m_mapIt == rhs.m_mapIt;
+      case iterator_type::Sequence:
+        return m_seqIt == rhs.m_seqIt;
+      case iterator_type::Map:
+        return m_mapIt == rhs.m_mapIt;
     }
     return true;
   }
 
-			void increment() {
+  template <typename W>
+  bool operator!=(const node_iterator_base<W>& rhs) const {
+    return !(*this == rhs);
+  }
+
+  node_iterator_base<V>& operator++() {
     switch (m_type) {
-					case iterator_type::None: break;
+      case iterator_type::NoneType:
+        break;
       case iterator_type::Sequence:
         ++m_seqIt;
         break;
@@ -103,17 +133,29 @@ namespace YAML
         m_mapIt = increment_until_defined(m_mapIt);
         break;
     }
+    return *this;
   }
 
-			value_type dereference() const {
+  node_iterator_base<V> operator++(int) {
+    node_iterator_base<V> iterator_pre(*this);
+    ++(*this);
+    return iterator_pre;
+  }
+
+  value_type operator*() const {
     switch (m_type) {
-					case iterator_type::None: return value_type();
+      case iterator_type::NoneType:
-					case iterator_type::Sequence: return value_type(**m_seqIt);
+        return value_type();
-					case iterator_type::Map: return value_type(*m_mapIt->first, *m_mapIt->second);
+      case iterator_type::Sequence:
+        return value_type(**m_seqIt);
+      case iterator_type::Map:
+        return value_type(*m_mapIt->first, *m_mapIt->second);
     }
     return value_type();
   }
 
+  proxy operator->() const { return proxy(**this); }
+
   MapIter increment_until_defined(MapIter it) {
     while (it != m_mapEnd && !is_defined(it))
       ++it;
@@ -131,8 +173,8 @@ namespace YAML
   MapIter m_mapIt, m_mapEnd;
 };
 
-		typedef node_iterator_base<node> node_iterator;
+using node_iterator = node_iterator_base<node>;
-		typedef node_iterator_base<const node> const_node_iterator;
+using const_node_iterator = node_iterator_base<const node>;
 }
 }
 

include/yaml-cpp/node/detail/node_ref.h

@@ -1,64 +1,93 @@
 #ifndef VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define VALUE_DETAIL_NODE_REF_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/type.h"
 #include "yaml-cpp/node/ptr.h"
 #include "yaml-cpp/node/detail/node_data.h"
-#include <boost/utility.hpp>
 
-namespace YAML
+namespace YAML {
-{
+namespace detail {
-	namespace detail
+class node_ref {
-	{
-		class node_ref: private boost::noncopyable
-		{
  public:
   node_ref() : m_pData(new node_data) {}
+  node_ref(const node_ref&) = delete;
+  node_ref& operator=(const node_ref&) = delete;
 
   bool is_defined() const { return m_pData->is_defined(); }
+  const Mark& mark() const { return m_pData->mark(); }
   NodeType::value type() const { return m_pData->type(); }
   const std::string& scalar() const { return m_pData->scalar(); }
   const std::string& tag() const { return m_pData->tag(); }
+  EmitterStyle::value style() const { return m_pData->style(); }
 
   void mark_defined() { m_pData->mark_defined(); }
   void set_data(const node_ref& rhs) { m_pData = rhs.m_pData; }
 
+  void set_mark(const Mark& mark) { m_pData->set_mark(mark); }
   void set_type(NodeType::value type) { m_pData->set_type(type); }
   void set_tag(const std::string& tag) { m_pData->set_tag(tag); }
   void set_null() { m_pData->set_null(); }
   void set_scalar(const std::string& scalar) { m_pData->set_scalar(scalar); }
+  void set_style(EmitterStyle::value style) { m_pData->set_style(style); }
 
   // size/iterator
   std::size_t size() const { return m_pData->size(); }
 
-			const_node_iterator begin() const { return static_cast<const node_data&>(*m_pData).begin(); }
+  const_node_iterator begin() const {
+    return static_cast<const node_data&>(*m_pData).begin();
+  }
   node_iterator begin() { return m_pData->begin(); }
 
-			const_node_iterator end() const { return static_cast<const node_data&>(*m_pData).end(); }
+  const_node_iterator end() const {
+    return static_cast<const node_data&>(*m_pData).end();
+  }
   node_iterator end() { return m_pData->end(); }
 
   // sequence
-			void push_back(node& node, shared_memory_holder pMemory) { m_pData->push_back(node, pMemory); }
+  void push_back(node& node, shared_memory_holder pMemory) {
-			void insert(node& key, node& value, shared_memory_holder pMemory) { m_pData->insert(key, value, pMemory); }
+    m_pData->push_back(node, pMemory);
+  }
+  void insert(node& key, node& value, shared_memory_holder pMemory) {
+    m_pData->insert(key, value, pMemory);
+  }
 
   // indexing
-			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) const { return static_cast<const node_data&>(*m_pData).get(key, pMemory); }
+  template <typename Key>
-			template<typename Key> node& get(const Key& key, shared_memory_holder pMemory) { return m_pData->get(key, pMemory); }
+  node* get(const Key& key, shared_memory_holder pMemory) const {
-			template<typename Key> bool remove(const Key& key, shared_memory_holder pMemory) { return m_pData->remove(key, pMemory); }
+    return static_cast<const node_data&>(*m_pData).get(key, pMemory);
+  }
+  template <typename Key>
+  node& get(const Key& key, shared_memory_holder pMemory) {
+    return m_pData->get(key, pMemory);
+  }
+  template <typename Key>
+  bool remove(const Key& key, shared_memory_holder pMemory) {
+    return m_pData->remove(key, pMemory);
+  }
 
-			node& get(node& key, shared_memory_holder pMemory) const { return static_cast<const node_data&>(*m_pData).get(key, pMemory); }
+  node* get(node& key, shared_memory_holder pMemory) const {
-			node& get(node& key, shared_memory_holder pMemory) { return m_pData->get(key, pMemory); }
+    return static_cast<const node_data&>(*m_pData).get(key, pMemory);
-			bool remove(node& key, shared_memory_holder pMemory) { return m_pData->remove(key, pMemory); }
+  }
+  node& get(node& key, shared_memory_holder pMemory) {
+    return m_pData->get(key, pMemory);
+  }
+  bool remove(node& key, shared_memory_holder pMemory) {
+    return m_pData->remove(key, pMemory);
+  }
 
   // map
   template <typename Key, typename Value>
-            void force_insert(const Key& key, const Value& value, shared_memory_holder pMemory) { m_pData->force_insert(key, value, pMemory); }
+  void force_insert(const Key& key, const Value& value,
+                    shared_memory_holder pMemory) {
+    m_pData->force_insert(key, value, pMemory);
+  }
 
  private:
   shared_node_data m_pData;

include/yaml-cpp/node/emit.h

@@ -1,23 +1,32 @@
 #ifndef NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NODE_EMIT_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 <iosfwd>
 
-namespace YAML
+#include "yaml-cpp/dll.h"
-{
+
+namespace YAML {
 class Emitter;
 class Node;
 
-	Emitter& operator << (Emitter& out, const Node& node);
+/**
-	std::ostream& operator << (std::ostream& out, const Node& node);
+ * Emits the node to the given {@link Emitter}. If there is an error in writing,
+ * {@link Emitter#good} will return false.
+ */
+YAML_CPP_API Emitter& operator<<(Emitter& out, const Node& node);
 
-	std::string Dump(const Node& node);
+/** Emits the node to the given output stream. */
-}
+YAML_CPP_API std::ostream& operator<<(std::ostream& out, const Node& node);
+
+/** Converts the node to a YAML string. */
+YAML_CPP_API std::string Dump(const Node& node);
+}  // namespace YAML
 
 #endif  // NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

include/yaml-cpp/node/impl.h

@@ -1,53 +1,63 @@
 #ifndef NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NODE_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/exceptions.h"
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/iterator.h"
 #include "yaml-cpp/node/detail/memory.h"
 #include "yaml-cpp/node/detail/node.h"
-#include "yaml-cpp/exceptions.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/node.h"
+#include <sstream>
 #include <string>
 
-namespace YAML
+namespace YAML {
-{
+inline Node::Node()
-	inline Node::Node(): m_pNode(NULL)
+    : m_isValid(true), m_invalidKey{}, m_pMemory(nullptr), m_pNode(nullptr) {}
-	{
-	}
 
-	inline Node::Node(NodeType::value type): m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node())
+inline Node::Node(NodeType::value type)
-	{
+    : m_isValid(true),
+      m_invalidKey{},
+      m_pMemory(new detail::memory_holder),
+      m_pNode(&m_pMemory->create_node()) {
   m_pNode->set_type(type);
 }
 
 template <typename T>
-	inline Node::Node(const T& rhs): m_pMemory(new detail::memory_holder), m_pNode(&m_pMemory->create_node())
+inline Node::Node(const T& rhs)
-	{
+    : m_isValid(true),
+      m_invalidKey{},
+      m_pMemory(new detail::memory_holder),
+      m_pNode(&m_pMemory->create_node()) {
   Assign(rhs);
 }
 
-    inline Node::Node(const detail::iterator_value& rhs): m_pMemory(rhs.m_pMemory), m_pNode(rhs.m_pNode)
+inline Node::Node(const detail::iterator_value& rhs)
-    {
+    : m_isValid(rhs.m_isValid),
-    }
+      m_invalidKey(rhs.m_invalidKey),
+      m_pMemory(rhs.m_pMemory),
+      m_pNode(rhs.m_pNode) {}
 
-	inline Node::Node(const Node& rhs): m_pMemory(rhs.m_pMemory), m_pNode(rhs.m_pNode)
+inline Node::Node(const Node& rhs) = default;
-	{
-	}
 
-	inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory): m_pMemory(pMemory), m_pNode(&node)
+inline Node::Node(Zombie)
-	{
+    : m_isValid(false), m_invalidKey{}, m_pMemory{}, m_pNode(nullptr) {}
-	}
 
-	inline Node::~Node()
+inline Node::Node(Zombie, const std::string& key)
-	{
+    : m_isValid(false), m_invalidKey(key), m_pMemory{}, m_pNode(nullptr) {}
-	}
 
-	inline void Node::EnsureNodeExists() const
+inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory)
-	{
+    : m_isValid(true), m_invalidKey{}, m_pMemory(pMemory), m_pNode(&node) {}
+
+inline Node::~Node() = default;
+
+inline void Node::EnsureNodeExists() const {
+  if (!m_isValid)
+    throw InvalidNode(m_invalidKey);
   if (!m_pNode) {
     m_pMemory.reset(new detail::memory_holder);
     m_pNode = &m_pMemory->create_node();
@@ -55,13 +65,23 @@ namespace YAML
   }
 }
 
-	inline bool Node::IsDefined() const
+inline bool Node::IsDefined() const {
-	{
+  if (!m_isValid) {
+    return false;
+  }
   return m_pNode ? m_pNode->is_defined() : true;
 }
 
-	inline NodeType::value Node::Type() const
+inline Mark Node::Mark() const {
-	{
+  if (!m_isValid) {
+    throw InvalidNode(m_invalidKey);
+  }
+  return m_pNode ? m_pNode->mark() : Mark::null_mark();
+}
+
+inline NodeType::value Node::Type() const {
+  if (!m_isValid)
+    throw InvalidNode(m_invalidKey);
   return m_pNode ? m_pNode->type() : NodeType::Null;
 }
 
@@ -73,7 +93,7 @@ namespace YAML
   explicit as_if(const Node& node_) : node(node_) {}
   const Node& node;
 
-        const T operator()(const S& fallback) const {
+  T operator()(const S& fallback) const {
     if (!node.m_pNode)
       return fallback;
 
@@ -89,7 +109,7 @@ namespace YAML
   explicit as_if(const Node& node_) : node(node_) {}
   const Node& node;
 
-        const std::string operator()(const S& fallback) const {
+  std::string operator()(const S& fallback) const {
     if (node.Type() != NodeType::Scalar)
       return fallback;
     return node.Scalar();
@@ -101,14 +121,14 @@ namespace YAML
   explicit as_if(const Node& node_) : node(node_) {}
   const Node& node;
 
-        const T operator()() const {
+  T operator()() const {
     if (!node.m_pNode)
-                throw TypedBadConversion<T>();
+      throw TypedBadConversion<T>(node.Mark());
 
     T t;
     if (convert<T>::decode(node, t))
       return t;
-            throw TypedBadConversion<T>();
+    throw TypedBadConversion<T>(node.Mark());
   }
 };
 
@@ -117,97 +137,109 @@ namespace YAML
   explicit as_if(const Node& node_) : node(node_) {}
   const Node& node;
 
-        const std::string operator()() const {
+  std::string operator()() const {
     if (node.Type() != NodeType::Scalar)
-                throw TypedBadConversion<std::string>();
+      throw TypedBadConversion<std::string>(node.Mark());
     return node.Scalar();
   }
 };
 
 // access functions
 template <typename T>
-	inline const T Node::as() const
+inline T Node::as() const {
-	{
+  if (!m_isValid)
+    throw InvalidNode(m_invalidKey);
   return as_if<T, void>(*this)();
 }
 
 template <typename T, typename S>
-    inline const T Node::as(const S& fallback) const
+inline T Node::as(const S& fallback) const {
-    {
+  if (!m_isValid)
+    return fallback;
   return as_if<T, S>(*this)(fallback);
 }
 
-	inline const std::string& Node::Scalar() const
+inline const std::string& Node::Scalar() const {
-	{
+  if (!m_isValid)
-		return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar;
+    throw InvalidNode(m_invalidKey);
+  return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar();
 }
 
-	inline const std::string& Node::Tag() const
+inline const std::string& Node::Tag() const {
-	{
+  if (!m_isValid)
-		return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar;
+    throw InvalidNode(m_invalidKey);
+  return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar();
 }
 
-	inline void Node::SetTag(const std::string& tag)
+inline void Node::SetTag(const std::string& tag) {
-	{
   EnsureNodeExists();
   m_pNode->set_tag(tag);
 }
 
+inline EmitterStyle::value Node::Style() const {
+  if (!m_isValid)
+    throw InvalidNode(m_invalidKey);
+  return m_pNode ? m_pNode->style() : EmitterStyle::Default;
+}
+
+inline void Node::SetStyle(EmitterStyle::value style) {
+  EnsureNodeExists();
+  m_pNode->set_style(style);
+}
+
 // assignment
-	inline bool Node::is(const Node& rhs) const
+inline bool Node::is(const Node& rhs) const {
-	{
+  if (!m_isValid || !rhs.m_isValid)
+    throw InvalidNode(m_invalidKey);
   if (!m_pNode || !rhs.m_pNode)
     return false;
   return m_pNode->is(*rhs.m_pNode);
 }
 
 template <typename T>
-	inline Node& Node::operator=(const T& rhs)
+inline Node& Node::operator=(const T& rhs) {
-	{
   Assign(rhs);
   return *this;
 }
 
-    inline void Node::clear()
+inline Node& Node::operator=(const Node& rhs) {
-    {
-        m_pNode = NULL;
-    }
-
-	template<typename T>
-	inline void Node::Assign(const T& rhs)
-	{
-		AssignData(convert<T>::encode(rhs));
-	}
-
-	template<>
-	inline void Node::Assign(const std::string& rhs)
-	{
-		EnsureNodeExists();
-		m_pNode->set_scalar(rhs);
-	}
-
-	inline void Node::Assign(const char *rhs)
-	{
-		EnsureNodeExists();
-		m_pNode->set_scalar(rhs);
-	}
-
-	inline void Node::Assign(char *rhs)
-	{
-		EnsureNodeExists();
-		m_pNode->set_scalar(rhs);
-	}
-	
-	inline Node& Node::operator=(const Node& rhs)
-	{
   if (is(rhs))
     return *this;
   AssignNode(rhs);
   return *this;
 }
 
-	inline void Node::AssignData(const Node& rhs)
+inline void Node::reset(const YAML::Node& rhs) {
-	{
+  if (!m_isValid || !rhs.m_isValid)
+    throw InvalidNode(m_invalidKey);
+  m_pMemory = rhs.m_pMemory;
+  m_pNode = rhs.m_pNode;
+}
+
+template <typename T>
+inline void Node::Assign(const T& rhs) {
+  if (!m_isValid)
+    throw InvalidNode(m_invalidKey);
+  AssignData(convert<T>::encode(rhs));
+}
+
+template <>
+inline void Node::Assign(const std::string& rhs) {
+  EnsureNodeExists();
+  m_pNode->set_scalar(rhs);
+}
+
+inline void Node::Assign(const char* rhs) {
+  EnsureNodeExists();
+  m_pNode->set_scalar(rhs);
+}
+
+inline void Node::Assign(char* rhs) {
+  EnsureNodeExists();
+  m_pNode->set_scalar(rhs);
+}
+
+inline void Node::AssignData(const Node& rhs) {
   EnsureNodeExists();
   rhs.EnsureNodeExists();
 
@@ -215,8 +247,9 @@ namespace YAML
   m_pMemory->merge(*rhs.m_pMemory);
 }
 
-	inline void Node::AssignNode(const Node& rhs)
+inline void Node::AssignNode(const Node& rhs) {
-	{
+  if (!m_isValid)
+    throw InvalidNode(m_invalidKey);
   rhs.EnsureNodeExists();
 
   if (!m_pNode) {
@@ -231,40 +264,46 @@ namespace YAML
 }
 
 // size/iterator
-	inline std::size_t Node::size() const
+inline std::size_t Node::size() const {
-	{
+  if (!m_isValid)
+    throw InvalidNode(m_invalidKey);
   return m_pNode ? m_pNode->size() : 0;
 }
 
-	inline const_iterator Node::begin() const
+inline const_iterator Node::begin() const {
-	{
+  if (!m_isValid)
-		return m_pNode ? const_iterator(m_pNode->begin(), m_pMemory) : const_iterator();
+    return const_iterator();
+  return m_pNode ? const_iterator(m_pNode->begin(), m_pMemory)
+                 : const_iterator();
 }
 
-	inline iterator Node::begin()
+inline iterator Node::begin() {
-	{
+  if (!m_isValid)
+    return iterator();
   return m_pNode ? iterator(m_pNode->begin(), m_pMemory) : iterator();
 }
 
-	inline const_iterator Node::end() const
+inline const_iterator Node::end() const {
-	{
+  if (!m_isValid)
+    return const_iterator();
   return m_pNode ? const_iterator(m_pNode->end(), m_pMemory) : const_iterator();
 }
 
-	inline iterator Node::end()
+inline iterator Node::end() {
-	{
+  if (!m_isValid)
+    return iterator();
   return m_pNode ? iterator(m_pNode->end(), m_pMemory) : iterator();
 }
 
 // sequence
 template <typename T>
-	inline void Node::push_back(const T& rhs)
+inline void Node::push_back(const T& rhs) {
-	{
+  if (!m_isValid)
+    throw InvalidNode(m_invalidKey);
   push_back(Node(rhs));
 }
 
-	inline void Node::push_back(const Node& rhs)
+inline void Node::push_back(const Node& rhs) {
-	{
   EnsureNodeExists();
   rhs.EnsureNodeExists();
 
@@ -278,7 +317,7 @@ namespace YAML
 struct to_value_t {
   explicit to_value_t(const T& t_) : t(t_) {}
   const T& t;
-            typedef const T& return_type;
+  using return_type = const T &;
 
   const T& operator()() const { return t; }
 };
@@ -287,7 +326,7 @@ namespace YAML
 struct to_value_t<const char*> {
   explicit to_value_t(const char* t_) : t(t_) {}
   const char* t;
-            typedef std::string return_type;
+  using return_type = std::string;
 
   const std::string operator()() const { return t; }
 };
@@ -296,7 +335,7 @@ namespace YAML
 struct to_value_t<char*> {
   explicit to_value_t(char* t_) : t(t_) {}
   const char* t;
-            typedef std::string return_type;
+  using return_type = std::string;
 
   const std::string operator()() const { return t; }
 };
@@ -305,7 +344,7 @@ namespace YAML
 struct to_value_t<char[N]> {
   explicit to_value_t(const char* t_) : t(t_) {}
   const char* t;
-            typedef std::string return_type;
+  using return_type = std::string;
 
   const std::string operator()() const { return t; }
 };
@@ -315,50 +354,59 @@ namespace YAML
 inline typename to_value_t<T>::return_type to_value(const T& t) {
   return to_value_t<T>(t)();
 }
+}  // namespace detail
+
+template<typename Key>
+std::string key_to_string(const Key& key) {
+  return streamable_to_string<Key, is_streamable<std::stringstream, Key>::value>().impl(key);
 }
 
 // indexing
 template <typename Key>
-	inline const Node Node::operator[](const Key& key) const
+inline const Node Node::operator[](const Key& key) const {
-	{
   EnsureNodeExists();
-		detail::node& value = static_cast<const detail::node&>(*m_pNode).get(detail::to_value(key), m_pMemory);
+  detail::node* value = static_cast<const detail::node&>(*m_pNode).get(
-		return Node(value, m_pMemory);
+      detail::to_value(key), m_pMemory);
+  if (!value) {
+    return Node(ZombieNode, key_to_string(key));
+  }
+  return Node(*value, m_pMemory);
 }
 
 template <typename Key>
-	inline Node Node::operator[](const Key& key)
+inline Node Node::operator[](const Key& key) {
-	{
   EnsureNodeExists();
   detail::node& value = m_pNode->get(detail::to_value(key), m_pMemory);
   return Node(value, m_pMemory);
 }
 
 template <typename Key>
-	inline bool Node::remove(const Key& key)
+inline bool Node::remove(const Key& key) {
-	{
   EnsureNodeExists();
   return m_pNode->remove(detail::to_value(key), m_pMemory);
 }
 
-	inline const Node Node::operator[](const Node& key) const
+inline const Node Node::operator[](const Node& key) const {
-	{
   EnsureNodeExists();
   key.EnsureNodeExists();
-		detail::node& value = static_cast<const detail::node&>(*m_pNode).get(*key.m_pNode, m_pMemory);
+  m_pMemory->merge(*key.m_pMemory);
-		return Node(value, m_pMemory);
+  detail::node* value =
+      static_cast<const detail::node&>(*m_pNode).get(*key.m_pNode, m_pMemory);
+  if (!value) {
+    return Node(ZombieNode, key_to_string(key));
+  }
+  return Node(*value, m_pMemory);
 }
 
-	inline Node Node::operator[](const Node& key)
+inline Node Node::operator[](const Node& key) {
-	{
   EnsureNodeExists();
   key.EnsureNodeExists();
+  m_pMemory->merge(*key.m_pMemory);
   detail::node& value = m_pNode->get(*key.m_pNode, m_pMemory);
   return Node(value, m_pMemory);
 }
 
-	inline bool Node::remove(const Node& key)
+inline bool Node::remove(const Node& key) {
-	{
   EnsureNodeExists();
   key.EnsureNodeExists();
   return m_pNode->remove(*key.m_pNode, m_pMemory);
@@ -366,17 +414,14 @@ namespace YAML
 
 // map
 template <typename Key, typename Value>
-    inline void Node::force_insert(const Key& key, const Value& value)
+inline void Node::force_insert(const Key& key, const Value& value) {
-    {
   EnsureNodeExists();
-		m_pNode->force_insert(detail::to_value(key), detail::to_value(value), m_pMemory);
+  m_pNode->force_insert(detail::to_value(key), detail::to_value(value),
+                        m_pMemory);
 }
 
 // free functions
-	inline bool operator==(const Node& lhs, const Node& rhs)
+inline bool operator==(const Node& lhs, const Node& rhs) { return lhs.is(rhs); }
-	{
+}  // namespace YAML
-		return lhs.is(rhs);
-	}
-}
 
 #endif  // NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/node/iterator.h

@@ -1,11 +1,12 @@
 #ifndef VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define VALUE_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/node.h"
 #include "yaml-cpp/node/detail/iterator_fwd.h"
@@ -14,13 +15,15 @@
 #include <utility>
 #include <vector>
 
-namespace YAML
+namespace YAML {
-{
 namespace detail {
 struct iterator_value : public Node, std::pair<Node, Node> {
-			iterator_value() {}
+  iterator_value() = default;
-			explicit iterator_value(const Node& rhs): Node(rhs) {}
+  explicit iterator_value(const Node& rhs)
-			explicit iterator_value(const Node& key, const Node& value): std::pair<Node, Node>(key, value) {}
+      : Node(rhs),
+        std::pair<Node, Node>(Node(Node::ZombieNode), Node(Node::ZombieNode)) {}
+  explicit iterator_value(const Node& key, const Node& value)
+      : Node(Node::ZombieNode), std::pair<Node, Node>(key, value) {}
 };
 }
 }

include/yaml-cpp/node/node.h

@@ -1,39 +1,55 @@
 #ifndef NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NODE_NODE_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 <stdexcept>
+#include <string>
 
 #include "yaml-cpp/dll.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/node/detail/iterator_fwd.h"
 #include "yaml-cpp/node/ptr.h"
 #include "yaml-cpp/node/type.h"
-#include "yaml-cpp/node/detail/iterator_fwd.h"
-#include "yaml-cpp/node/detail/bool_type.h"
-#include <stdexcept>
 
-namespace YAML
+namespace YAML {
-{
+namespace detail {
-	class Node
+class node;
-	{
+class node_data;
+struct iterator_value;
+}  // namespace detail
+}  // namespace YAML
+
+namespace YAML {
+class YAML_CPP_API Node {
  public:
   friend class NodeBuilder;
   friend class NodeEvents;
+  friend struct detail::iterator_value;
+  friend class detail::node;
   friend class detail::node_data;
-		template<typename> friend class detail::iterator_base;
+  template <typename>
-        template<typename T, typename S> friend struct as_if;
+  friend class detail::iterator_base;
+  template <typename T, typename S>
+  friend struct as_if;
 
-        typedef YAML::iterator iterator;
+  using iterator = YAML::iterator;
-        typedef YAML::const_iterator const_iterator;
+  using const_iterator = YAML::const_iterator;
 
   Node();
   explicit Node(NodeType::value type);
-		template<typename T> explicit Node(const T& rhs);
+  template <typename T>
+  explicit Node(const T& rhs);
   explicit Node(const detail::iterator_value& rhs);
   Node(const Node& rhs);
   ~Node();
 
+  YAML::Mark Mark() const;
   NodeType::value Type() const;
   bool IsDefined() const;
   bool IsNull() const { return Type() == NodeType::Null; }
@@ -42,21 +58,30 @@ namespace YAML
   bool IsMap() const { return Type() == NodeType::Map; }
 
   // bool conversions
-		YAML_CPP_OPERATOR_BOOL();
+  explicit operator bool() const { return IsDefined(); }
   bool operator!() const { return !IsDefined(); }
 
   // access
-		template<typename T> const T as() const;
+  template <typename T>
-		template<typename T, typename S> const T as(const S& fallback) const;
+  T as() const;
+  template <typename T, typename S>
+  T as(const S& fallback) const;
   const std::string& Scalar() const;
+
   const std::string& Tag() const;
   void SetTag(const std::string& tag);
 
+  // style
+  // WARNING: This API might change in future releases.
+  EmitterStyle::value Style() const;
+  void SetStyle(EmitterStyle::value style);
+
   // assignment
   bool is(const Node& rhs) const;
-		template<typename T> Node& operator=(const T& rhs);
+  template <typename T>
+  Node& operator=(const T& rhs);
   Node& operator=(const Node& rhs);
-        void clear();
+  void reset(const Node& rhs = Node());
 
   // size/iterator
   std::size_t size() const;
@@ -68,13 +93,17 @@ namespace YAML
   iterator end();
 
   // sequence
-		template<typename T> void push_back(const T& rhs);
+  template <typename T>
+  void push_back(const T& rhs);
   void push_back(const Node& rhs);
 
   // indexing
-		template<typename Key> const Node operator[](const Key& key) const;
+  template <typename Key>
-		template<typename Key> Node operator[](const Key& key);
+  const Node operator[](const Key& key) const;
-		template<typename Key> bool remove(const Key& key);
+  template <typename Key>
+  Node operator[](const Key& key);
+  template <typename Key>
+  bool remove(const Key& key);
 
   const Node operator[](const Node& key) const;
   Node operator[](const Node& key);
@@ -85,11 +114,15 @@ namespace YAML
   void force_insert(const Key& key, const Value& value);
 
  private:
+  enum Zombie { ZombieNode };
+  explicit Node(Zombie);
+  explicit Node(Zombie, const std::string&);
   explicit Node(detail::node& node, detail::shared_memory_holder pMemory);
 
   void EnsureNodeExists() const;
 
-		template<typename T> void Assign(const T& rhs);
+  template <typename T>
+  void Assign(const T& rhs);
   void Assign(const char* rhs);
   void Assign(char* rhs);
 
@@ -97,13 +130,16 @@ namespace YAML
   void AssignNode(const Node& rhs);
 
  private:
+  bool m_isValid;
+  // String representation of invalid key, if the node is invalid.
+  std::string m_invalidKey;
   mutable detail::shared_memory_holder m_pMemory;
   mutable detail::node* m_pNode;
 };
 
-	bool operator==(const Node& lhs, const Node& rhs);
+YAML_CPP_API bool operator==(const Node& lhs, const Node& rhs);
 
-    Node Clone(const Node& node);
+YAML_CPP_API Node Clone(const Node& node);
 
 template <typename T>
 struct convert;

include/yaml-cpp/node/parse.h

@@ -1,7 +1,9 @@
 #ifndef VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define VALUE_PARSE_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,20 +11,68 @@
 #include <string>
 #include <vector>
 
-namespace YAML
+#include "yaml-cpp/dll.h"
-{
+
+namespace YAML {
 class Node;
 
-	Node Load(const std::string& input);
+/**
-	Node Load(const char *input);
+ * Loads the input string as a single YAML document.
-	Node Load(std::istream& input);
+ *
-    Node LoadFile(const std::string& filename);
+ * @throws {@link ParserException} if it is malformed.
+ */
+YAML_CPP_API Node Load(const std::string& input);
 
-	std::vector<Node> LoadAll(const std::string& input);
+/**
-	std::vector<Node> LoadAll(const char *input);
+ * Loads the input string as a single YAML document.
-	std::vector<Node> LoadAll(std::istream& input);
+ *
-    std::vector<Node> LoadAllFromFile(const std::string& filename);
+ * @throws {@link ParserException} if it is malformed.
-}
+ */
+YAML_CPP_API Node Load(const char* input);
+
+/**
+ * Loads the input stream as a single YAML document.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ */
+YAML_CPP_API Node Load(std::istream& input);
+
+/**
+ * Loads the input file as a single YAML document.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ * @throws {@link BadFile} if the file cannot be loaded.
+ */
+YAML_CPP_API Node LoadFile(const std::string& filename);
+
+/**
+ * Loads the input string as a list of YAML documents.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ */
+YAML_CPP_API std::vector<Node> LoadAll(const std::string& input);
+
+/**
+ * Loads the input string as a list of YAML documents.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ */
+YAML_CPP_API std::vector<Node> LoadAll(const char* input);
+
+/**
+ * Loads the input stream as a list of YAML documents.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ */
+YAML_CPP_API std::vector<Node> LoadAll(std::istream& input);
+
+/**
+ * Loads the input file as a list of YAML documents.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ * @throws {@link BadFile} if the file cannot be loaded.
+ */
+YAML_CPP_API std::vector<Node> LoadAllFromFile(const std::string& filename);
+}  // namespace YAML
 
 #endif  // VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

include/yaml-cpp/node/ptr.h

@@ -1,16 +1,16 @@
 #ifndef VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define VALUE_PTR_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 <boost/shared_ptr.hpp>
+#include <memory>
 
-namespace YAML
+namespace YAML {
-{
 namespace detail {
 class node;
 class node_ref;
@@ -18,11 +18,11 @@ namespace YAML
 class memory;
 class memory_holder;
 
-		typedef boost::shared_ptr<node> shared_node;
+using shared_node = std::shared_ptr<node>;
-		typedef boost::shared_ptr<node_ref> shared_node_ref;
+using shared_node_ref = std::shared_ptr<node_ref>;
-		typedef boost::shared_ptr<node_data> shared_node_data;
+using shared_node_data = std::shared_ptr<node_data>;
-		typedef boost::shared_ptr<memory_holder> shared_memory_holder;
+using shared_memory_holder = std::shared_ptr<memory_holder>;
-		typedef boost::shared_ptr<memory> shared_memory;
+using shared_memory = std::shared_ptr<memory>;
 }
 }
 

include/yaml-cpp/node/type.h

@@ -1,14 +1,16 @@
 #ifndef VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define VALUE_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 YAML
+struct NodeType {
-{
+  enum value { Undefined, Null, Scalar, Sequence, Map };
-	struct NodeType { enum value { Undefined, Null, Scalar, Sequence, Map }; };	
+};
 }
 
 #endif  // VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/noexcept.h

@@ -0,0 +1,18 @@
+#ifndef NOEXCEPT_H_768872DA_476C_11EA_88B8_90B11C0C0FF8
+#define NOEXCEPT_H_768872DA_476C_11EA_88B8_90B11C0C0FF8
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+// This is here for compatibility with older versions of Visual Studio
+// which don't support noexcept.
+#if defined(_MSC_VER) && _MSC_VER < 1900
+    #define YAML_CPP_NOEXCEPT _NOEXCEPT
+#else
+    #define YAML_CPP_NOEXCEPT noexcept
+#endif
+
+#endif

include/yaml-cpp/noncopyable.h

@@ -1,25 +0,0 @@
-#ifndef NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
-#pragma once
-#endif
-
-#include "yaml-cpp/dll.h"
-
-namespace YAML
-{
-	// this is basically boost::noncopyable
-	class YAML_CPP_API noncopyable
-	{
-	protected:
-		noncopyable() {}
-		~noncopyable() {}
-			
-	private:
-		noncopyable(const noncopyable&);
-		const noncopyable& operator = (const noncopyable&);
-	};
-}
-
-#endif // NONCOPYABLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/null.h

@@ -1,15 +1,16 @@
 #ifndef NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NULL_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 <string>
 
-namespace YAML
+namespace YAML {
-{
 class Node;
 
 struct YAML_CPP_API _Null {};
@@ -17,9 +18,9 @@ namespace YAML
 inline bool operator!=(const _Null&, const _Null&) { return false; }
 
 YAML_CPP_API bool IsNull(const Node& node);  // old API only
+YAML_CPP_API bool IsNullString(const std::string& str);
 
 extern YAML_CPP_API _Null Null;
 }
 
 #endif  // NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

include/yaml-cpp/ostream_wrapper.h

@@ -1,21 +1,26 @@
 #ifndef OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define OSTREAM_WRAPPER_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
+#include "yaml-cpp/dll.h"
-{
+
-	class ostream_wrapper
+namespace YAML {
-	{
+class YAML_CPP_API ostream_wrapper {
  public:
   ostream_wrapper();
   explicit ostream_wrapper(std::ostream& stream);
+  ostream_wrapper(const ostream_wrapper&) = delete;
+  ostream_wrapper(ostream_wrapper&&) = delete;
+  ostream_wrapper& operator=(const ostream_wrapper&) = delete;
+  ostream_wrapper& operator=(ostream_wrapper&&) = delete;
   ~ostream_wrapper();
 
   void write(const std::string& str);
@@ -25,7 +30,7 @@ namespace YAML
 
   const char* str() const {
     if (m_pStream) {
-                return 0;
+      return nullptr;
     } else {
       m_buffer[m_pos] = '\0';
       return &m_buffer[0];
@@ -42,7 +47,7 @@ namespace YAML
 
  private:
   mutable std::vector<char> m_buffer;
-        std::ostream *m_pStream;
+  std::ostream* const m_pStream;
 
   std::size_t m_pos;
   std::size_t m_row, m_col;
@@ -50,12 +55,14 @@ namespace YAML
 };
 
 template <std::size_t N>
-	inline ostream_wrapper& operator << (ostream_wrapper& stream, const char (&str)[N]) {
+inline ostream_wrapper& operator<<(ostream_wrapper& stream,
+                                   const char (&str)[N]) {
   stream.write(str, N - 1);
   return stream;
 }
 
-	inline ostream_wrapper& operator << (ostream_wrapper& stream, const std::string& str) {
+inline ostream_wrapper& operator<<(ostream_wrapper& stream,
+                                   const std::string& str) {
   stream.write(str);
   return stream;
 }
@@ -64,6 +71,6 @@ namespace YAML
   stream.write(&ch, 1);
   return stream;
 }
-}
+}  // namespace YAML
 
 #endif  // OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/parser.h

@@ -1,47 +1,90 @@
 #ifndef PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define PARSER_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/noncopyable.h"
 #include <ios>
 #include <memory>
 
-namespace YAML
+#include "yaml-cpp/dll.h"
-{
+
+namespace YAML {
+class EventHandler;
+class Node;
+class Scanner;
 struct Directives;
 struct Token;
-	class EventHandler;
-	class Scanner;
 
-	class YAML_CPP_API Parser: private noncopyable
+/**
-	{
+ * A parser turns a stream of bytes into one stream of "events" per YAML
+ * document in the input stream.
+ */
+class YAML_CPP_API Parser {
  public:
+  /** Constructs an empty parser (with no input. */
   Parser();
-		Parser(std::istream& in);
+
+  Parser(const Parser&) = delete;
+  Parser(Parser&&) = delete;
+  Parser& operator=(const Parser&) = delete;
+  Parser& operator=(Parser&&) = delete;
+
+  /**
+   * Constructs a parser from the given input stream. The input stream must
+   * live as long as the parser.
+   */
+  explicit Parser(std::istream& in);
+
   ~Parser();
 
-		operator bool() const;
+  /** Evaluates to true if the parser has some valid input to be read. */
+  explicit operator bool() const;
 
+  /**
+   * Resets the parser with the given input stream. Any existing state is
+   * erased.
+   */
   void Load(std::istream& in);
+
+  /**
+   * Handles the next document by calling events on the {@code eventHandler}.
+   *
+   * @throw a ParserException on error.
+   * @return false if there are no more documents
+   */
   bool HandleNextDocument(EventHandler& eventHandler);
 
   void PrintTokens(std::ostream& out);
 
  private:
+  /**
+   * Reads any directives that are next in the queue, setting the internal
+   * {@code m_pDirectives} state.
+   */
   void ParseDirectives();
+
   void HandleDirective(const Token& token);
+
+  /**
+   * Handles a "YAML" directive, which should be of the form 'major.minor' (like
+   * a version number).
+   */
   void HandleYamlDirective(const Token& token);
+
+  /**
+   * Handles a "TAG" directive, which should be of the form 'handle prefix',
+   * where 'handle' is converted to 'prefix' in the file.
+   */
   void HandleTagDirective(const Token& token);
 
  private:
-		std::auto_ptr<Scanner> m_pScanner;
+  std::unique_ptr<Scanner> m_pScanner;
-		std::auto_ptr<Directives> m_pDirectives;
+  std::unique_ptr<Directives> m_pDirectives;
 };
-}
+}  // namespace YAML
 
 #endif  // PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/stlemitter.h

@@ -1,18 +1,18 @@
 #ifndef STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define STLEMITTER_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 <vector>
 #include <list>
 #include <set>
 #include <map>
 
-namespace YAML
+namespace YAML {
-{
 template <typename Seq>
 inline Emitter& EmitSeq(Emitter& emitter, const Seq& seq) {
   emitter << BeginSeq;

include/yaml-cpp/traits.h

@@ -1,38 +1,90 @@
 #ifndef TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define TRAITS_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 <type_traits>
+#include <utility>
+#include <string>
+#include <sstream>
 
-namespace YAML
+namespace YAML {
-{
 template <typename>
-	struct is_numeric { enum { value = false }; };
+struct is_numeric {
+  enum { value = false };
+};
 
-	template <> struct is_numeric <char> { enum { value = true }; };
+template <>
-	template <> struct is_numeric <unsigned char> { enum { value = true }; };
+struct is_numeric<char> {
-	template <> struct is_numeric <int> { enum { value = true }; };
+  enum { value = true };
-	template <> struct is_numeric <unsigned int> { enum { value = true }; };
+};
-	template <> struct is_numeric <long int> { enum { value = true }; };
+template <>
-	template <> struct is_numeric <unsigned long int> { enum { value = true }; };
+struct is_numeric<unsigned char> {
-	template <> struct is_numeric <short int> { enum { value = true }; };
+  enum { value = true };
-	template <> struct is_numeric <unsigned short int> { enum { value = true }; };
+};
+template <>
+struct is_numeric<int> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<unsigned int> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<long int> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<unsigned long int> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<short int> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<unsigned short int> {
+  enum { value = true };
+};
 #if defined(_MSC_VER) && (_MSC_VER < 1310)
-	template <> struct is_numeric <__int64> { enum { value = true }; };
+template <>
-	template <> struct is_numeric <unsigned __int64> { enum { value = true }; };
+struct is_numeric<__int64> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<unsigned __int64> {
+  enum { value = true };
+};
 #else
-	template <> struct is_numeric <long long> { enum { value = true }; };
+template <>
-	template <> struct is_numeric <unsigned long long> { enum { value = true }; };
+struct is_numeric<long long> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<unsigned long long> {
+  enum { value = true };
+};
 #endif
-	template <> struct is_numeric <float> { enum { value = true }; };
+template <>
-	template <> struct is_numeric <double> { enum { value = true }; };
+struct is_numeric<float> {
-	template <> struct is_numeric <long double> { enum { value = true }; };
+  enum { value = true };
+};
+template <>
+struct is_numeric<double> {
+  enum { value = true };
+};
+template <>
+struct is_numeric<long double> {
+  enum { value = true };
+};
 
 template <bool, class T = void>
 struct enable_if_c {
-	  typedef T type;
+  using type = T;
 };
 
 template <class T>
@@ -43,7 +95,7 @@ namespace YAML
 
 template <bool, class T = void>
 struct disable_if_c {
-	  typedef T type;
+  using type = T;
 };
 
 template <class T>
@@ -53,5 +105,31 @@ namespace YAML
 struct disable_if : public disable_if_c<Cond::value, T> {};
 }
 
-#endif // TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+template <typename S, typename T>
+struct is_streamable {
+  template <typename SS, typename TT>
+  static auto test(int)
+      -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());
 
+  template <typename, typename>
+  static auto test(...) -> std::false_type;
+
+  static const bool value = decltype(test<S, T>(0))::value;
+};
+
+template<typename Key, bool Streamable>
+struct streamable_to_string {
+  static std::string impl(const Key& key) {
+    std::stringstream ss;
+    ss << key;
+    return ss.str();
+  }
+};
+
+template<typename Key>
+struct streamable_to_string<Key, false> {
+  static std::string impl(const Key&) {
+    return "";
+  }
+};
+#endif  // TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66

include/yaml-cpp/yaml.h

@@ -1,12 +1,15 @@
 #ifndef YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define YAML_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/parser.h"
 #include "yaml-cpp/emitter.h"
+#include "yaml-cpp/emitterstyle.h"
 #include "yaml-cpp/stlemitter.h"
 #include "yaml-cpp/exceptions.h"
 

src/binary.cpp

@@ -1,11 +1,12 @@
 #include "yaml-cpp/binary.h"
 
-namespace YAML
+#include <cctype>
-{
-    static const char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-    std::string EncodeBase64(const unsigned char *data, std::size_t size)
+namespace YAML {
-    {
+static const char encoding[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+std::string EncodeBase64(const unsigned char *data, std::size_t size) {
   const char PAD = '=';
 
   std::string ret;
@@ -44,27 +45,28 @@ namespace YAML
 }
 
 static const unsigned char decoding[] = {
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62,  255,
-         52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255,  0,255,255,
+    255, 255, 63,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
-        255,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+    255, 0,   255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
-         15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255,
+    10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
-        255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+    25,  255, 255, 255, 255, 255, 255, 26,  27,  28,  29,  30,  31,  32,  33,
-         41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255,
+    34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    49,  50,  51,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255,
 };
 
-    std::vector<unsigned char> DecodeBase64(const std::string& input)
+std::vector<unsigned char> DecodeBase64(const std::string &input) {
-    {
+  using ret_type = std::vector<unsigned char>;
-        typedef std::vector<unsigned char> ret_type;
   if (input.empty())
     return ret_type();
 
@@ -72,19 +74,24 @@ namespace YAML
   unsigned char *out = &ret[0];
 
   unsigned value = 0;
-        for(std::size_t i=0;i<input.size();i++) {
+  for (std::size_t i = 0, cnt = 0; i < input.size(); i++) {
+    if (std::isspace(input[i])) {
+      // skip newlines
+      continue;
+    }
     unsigned char d = decoding[static_cast<unsigned>(input[i])];
     if (d == 255)
       return ret_type();
 
     value = (value << 6) | d;
-            if(i % 4 == 3) {
+    if (cnt % 4 == 3) {
       *out++ = value >> 16;
       if (i > 0 && input[i - 1] != '=')
         *out++ = value >> 8;
       if (input[i] != '=')
         *out++ = value;
     }
+    ++cnt;
   }
 
   ret.resize(out - &ret[0]);

src/collectionstack.h

@@ -1,35 +1,41 @@
 #ifndef COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define COLLECTIONSTACK_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 <stack>
 #include <cassert>
+#include <stack>
 
-namespace YAML
+namespace YAML {
-{
 struct CollectionType {
-		enum value { None, BlockMap, BlockSeq, FlowMap, FlowSeq, CompactMap };
+  enum value { NoCollection, BlockMap, BlockSeq, FlowMap, FlowSeq, CompactMap };
 };
 
-	class CollectionStack
+class CollectionStack {
-	{
  public:
+  CollectionStack() : collectionStack{} {}
   CollectionType::value GetCurCollectionType() const {
     if (collectionStack.empty())
-				return CollectionType::None;
+      return CollectionType::NoCollection;
     return collectionStack.top();
   }
 
-		void PushCollectionType(CollectionType::value type) { collectionStack.push(type); }
+  void PushCollectionType(CollectionType::value type) {
-		void PopCollectionType(CollectionType::value type) { assert(type == GetCurCollectionType()); collectionStack.pop(); }
+    collectionStack.push(type);
+  }
+  void PopCollectionType(CollectionType::value type) {
+    assert(type == GetCurCollectionType());
+    (void)type;
+    collectionStack.pop();
+  }
 
  private:
   std::stack<CollectionType::value> collectionStack;
 };
-}
+}  // namespace YAML
 
 #endif  // COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/contrib/graphbuilder.cpp

@@ -1,16 +1,17 @@
-#include "yaml-cpp/parser.h"
-#include "yaml-cpp/contrib/graphbuilder.h"
 #include "graphbuilderadapter.h"
 
-namespace YAML
+#include "yaml-cpp/parser.h"  // IWYU pragma: keep
-{
+
-  void *BuildGraphOfNextDocument(Parser& parser, GraphBuilderInterface& graphBuilder)
+namespace YAML {
-  {
+class GraphBuilderInterface;
+
+void* BuildGraphOfNextDocument(Parser& parser,
+                               GraphBuilderInterface& graphBuilder) {
   GraphBuilderAdapter eventHandler(graphBuilder);
   if (parser.HandleNextDocument(eventHandler)) {
     return eventHandler.RootNode();
   } else {
-      return NULL;
+    return nullptr;
   }
 }
 }

src/contrib/graphbuilderadapter.cpp

@@ -1,11 +1,12 @@
 #include "graphbuilderadapter.h"
+#include "yaml-cpp/contrib/graphbuilder.h"
+
+namespace YAML {
+struct Mark;
 
-namespace YAML
-{
 int GraphBuilderAdapter::ContainerFrame::sequenceMarker;
 
-  void GraphBuilderAdapter::OnNull(const Mark& mark, anchor_t anchor)
+void GraphBuilderAdapter::OnNull(const Mark &mark, anchor_t anchor) {
-  {
   void *pParent = GetCurrentParent();
   void *pNode = m_builder.NewNull(mark, pParent);
   RegisterAnchor(anchor, pNode);
@@ -13,14 +14,13 @@ namespace YAML
   DispositionNode(pNode);
 }
 
-  void GraphBuilderAdapter::OnAlias(const Mark& mark, anchor_t anchor)
+void GraphBuilderAdapter::OnAlias(const Mark &mark, anchor_t anchor) {
-  {
   void *pReffedNode = m_anchors.Get(anchor);
   DispositionNode(m_builder.AnchorReference(mark, pReffedNode));
 }
 
-  void GraphBuilderAdapter::OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value)
+void GraphBuilderAdapter::OnScalar(const Mark &mark, const std::string &tag,
-  {
+                                   anchor_t anchor, const std::string &value) {
   void *pParent = GetCurrentParent();
   void *pNode = m_builder.NewScalar(mark, tag, pParent, value);
   RegisterAnchor(anchor, pNode);
@@ -28,54 +28,52 @@ namespace YAML
   DispositionNode(pNode);
 }
 
-  void GraphBuilderAdapter::OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor)
+void GraphBuilderAdapter::OnSequenceStart(const Mark &mark,
-  {
+                                          const std::string &tag,
+                                          anchor_t anchor,
+                                          EmitterStyle::value /* style */) {
   void *pNode = m_builder.NewSequence(mark, tag, GetCurrentParent());
   m_containers.push(ContainerFrame(pNode));
   RegisterAnchor(anchor, pNode);
 }
 
-  void GraphBuilderAdapter::OnSequenceEnd()
+void GraphBuilderAdapter::OnSequenceEnd() {
-  {
   void *pSequence = m_containers.top().pContainer;
   m_containers.pop();
 
   DispositionNode(pSequence);
 }
 
-  void GraphBuilderAdapter::OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor)
+void GraphBuilderAdapter::OnMapStart(const Mark &mark, const std::string &tag,
-  {
+                                     anchor_t anchor,
+                                     EmitterStyle::value /* style */) {
   void *pNode = m_builder.NewMap(mark, tag, GetCurrentParent());
   m_containers.push(ContainerFrame(pNode, m_pKeyNode));
-    m_pKeyNode = NULL;
+  m_pKeyNode = nullptr;
   RegisterAnchor(anchor, pNode);
 }
 
-  void GraphBuilderAdapter::OnMapEnd()
+void GraphBuilderAdapter::OnMapEnd() {
-  {
   void *pMap = m_containers.top().pContainer;
   m_pKeyNode = m_containers.top().pPrevKeyNode;
   m_containers.pop();
   DispositionNode(pMap);
 }
 
-  void *GraphBuilderAdapter::GetCurrentParent() const
+void *GraphBuilderAdapter::GetCurrentParent() const {
-  {
   if (m_containers.empty()) {
-      return NULL;
+    return nullptr;
   }
   return m_containers.top().pContainer;
 }
 
-  void GraphBuilderAdapter::RegisterAnchor(anchor_t anchor, void *pNode)
+void GraphBuilderAdapter::RegisterAnchor(anchor_t anchor, void *pNode) {
-  {
   if (anchor) {
     m_anchors.Register(anchor, pNode);
   }
 }
 
-  void GraphBuilderAdapter::DispositionNode(void *pNode)
+void GraphBuilderAdapter::DispositionNode(void *pNode) {
-  {
   if (m_containers.empty()) {
     m_pRootNode = pNode;
     return;
@@ -85,7 +83,7 @@ namespace YAML
   if (m_containers.top().isMap()) {
     if (m_pKeyNode) {
       m_builder.AssignInMap(pContainer, m_pKeyNode, pNode);
-        m_pKeyNode = NULL;
+      m_pKeyNode = nullptr;
     } else {
       m_pKeyNode = pNode;
     }

src/contrib/graphbuilderadapter.h

@@ -1,51 +1,65 @@
 #ifndef GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define GRAPHBUILDERADAPTER_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 <cstdlib>
 #include <map>
 #include <stack>
-#include "yaml-cpp/eventhandler.h"
+
+#include "yaml-cpp/anchor.h"
 #include "yaml-cpp/contrib/anchordict.h"
 #include "yaml-cpp/contrib/graphbuilder.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
 
-namespace YAML
+namespace YAML {
-{
+class GraphBuilderInterface;
-  class GraphBuilderAdapter : public EventHandler
+struct Mark;
-  {
+}  // namespace YAML
+
+namespace YAML {
+class GraphBuilderAdapter : public EventHandler {
  public:
   GraphBuilderAdapter(GraphBuilderInterface& builder)
-    : m_builder(builder), m_pRootNode(NULL), m_pKeyNode(NULL)
+      : m_builder(builder),
-    {
+        m_containers{},
-    }
+        m_anchors{},
+        m_pRootNode(nullptr),
+        m_pKeyNode(nullptr) {}
+  GraphBuilderAdapter(const GraphBuilderAdapter&) = delete;
+  GraphBuilderAdapter(GraphBuilderAdapter&&) = delete;
+  GraphBuilderAdapter& operator=(const GraphBuilderAdapter&) = delete;
+  GraphBuilderAdapter& operator=(GraphBuilderAdapter&&) = delete;
 
   virtual void OnDocumentStart(const Mark& mark) { (void)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 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 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);
+  virtual void OnMapStart(const Mark& mark, const std::string& tag,
+                          anchor_t anchor, EmitterStyle::value style);
   virtual void OnMapEnd();
 
   void* RootNode() const { return m_pRootNode; }
 
  private:
-    struct ContainerFrame
+  struct ContainerFrame {
-    {
     ContainerFrame(void* pSequence)
-      : pContainer(pSequence), pPrevKeyNode(&sequenceMarker)
+        : pContainer(pSequence), pPrevKeyNode(&sequenceMarker) {}
-      {}
+    ContainerFrame(void* pMap, void* pPreviousKeyNode)
-      ContainerFrame(void *pMap, void* pPrevKeyNode)
+        : pContainer(pMap), pPrevKeyNode(pPreviousKeyNode) {}
-      : pContainer(pMap), pPrevKeyNode(pPrevKeyNode)
-      {}
 
     void* pContainer;
     void* pPrevKeyNode;
@@ -68,6 +82,6 @@ namespace YAML
   void RegisterAnchor(anchor_t anchor, void* pNode);
   void DispositionNode(void* pNode);
 };
-}
+}  // namespace YAML
 
 #endif  // GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/contrib/yaml-cpp.natvis

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?> 
+<!-- MSVC Debugger visualization hints for YAML::Node and YAML::detail::node -->
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+  <Type Name="YAML::Node">
+    <DisplayString Condition="!m_isValid">{{invalid}}</DisplayString>
+    <DisplayString Condition="!m_pNode">{{pNode==nullptr}}</DisplayString>
+    <DisplayString>{{ {*m_pNode} }}</DisplayString>
+    <Expand>
+      <Item Condition="m_pNode->m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Scalar" Name="scalar">m_pNode->m_pRef._Ptr->m_pData._Ptr->m_scalar</Item>
+      <Item Condition="m_pNode->m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Sequence" Name="sequence">m_pNode->m_pRef._Ptr->m_pData._Ptr->m_sequence</Item>
+      <Item Condition="m_pNode->m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Map" Name="map">m_pNode->m_pRef._Ptr->m_pData._Ptr->m_map</Item>
+      <Item Name="[details]" >m_pNode->m_pRef._Ptr->m_pData._Ptr</Item>
+    </Expand>
+  </Type>
+
+  <Type Name="YAML::detail::node">
+    <DisplayString Condition="!m_pRef._Ptr">{{node:pRef==nullptr}}</DisplayString>
+    <DisplayString Condition="!m_pRef._Ptr->m_pData._Ptr">{{node:pRef->pData==nullptr}}</DisplayString>
+    <DisplayString Condition="!m_pRef._Ptr->m_pData._Ptr->m_isDefined">{{undefined}}</DisplayString>
+    <DisplayString Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Scalar">{{{m_pRef._Ptr->m_pData._Ptr->m_scalar}}}</DisplayString>
+    <DisplayString Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Map">{{ Map {m_pRef._Ptr->m_pData._Ptr->m_map}}}</DisplayString>
+    <DisplayString Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Sequence">{{ Seq {m_pRef._Ptr->m_pData._Ptr->m_sequence}}}</DisplayString>
+    <DisplayString>{{{m_pRef._Ptr->m_pData._Ptr->m_type}}}</DisplayString>
+    <Expand>
+      <Item Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Scalar" Name="scalar">m_pRef._Ptr->m_pData._Ptr->m_scalar</Item>
+      <Item Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Sequence" Name="sequence">m_pRef._Ptr->m_pData._Ptr->m_sequence</Item>
+      <Item Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Map" Name="map">m_pRef._Ptr->m_pData._Ptr->m_map</Item>
+      <Item Name="[details]" >m_pRef._Ptr->m_pData._Ptr</Item>
+    </Expand>
+  </Type>
+
+</AutoVisualizer>

src/contrib/yaml-cpp.natvis.md

@@ -0,0 +1,9 @@
+# MSVC debugger visualizer for YAML::Node
+
+## How to use
+Add yaml-cpp.natvis to your Visual C++ project like any other source file.  It will be included in the debug information, and improve debugger display on YAML::Node and contained types. 
+
+## Compatibility and Troubleshooting
+
+This has been tested for MSVC 2017. It is expected to be compatible with VS 2015 and VS 2019. If you have any problems, you can open an issue here: https://github.com/peterchen-cp/yaml-cpp-natvis
+

src/convert.cpp

@@ -1,26 +1,23 @@
-#include "yaml-cpp/node/convert.h"
-#include "yaml-cpp/node/impl.h"
 #include <algorithm>
 
-namespace
+#include "yaml-cpp/node/convert.h"
-{
+
+namespace {
 // we're not gonna mess with the mess that is all the isupper/etc. functions
 bool IsLower(char ch) { return 'a' <= ch && ch <= 'z'; }
 bool IsUpper(char ch) { return 'A' <= ch && ch <= 'Z'; }
 char ToLower(char ch) { return IsUpper(ch) ? ch + 'a' - 'A' : ch; }
 
-	std::string tolower(const std::string& str)
+std::string tolower(const std::string& str) {
-	{
   std::string s(str);
   std::transform(s.begin(), s.end(), s.begin(), ToLower);
   return s;
 }
 
 template <typename T>
-	bool IsEntirely(const std::string& str, T func)
+bool IsEntirely(const std::string& str, T func) {
-	{
+  for (char ch : str)
-		for(std::size_t i=0;i<str.size();i++)
+    if (!func(ch))
-			if(!func(str[i]))
       return false;
 
   return true;
@@ -31,8 +28,7 @@ namespace
 //   . UPPERCASE
 //   . lowercase
 //   . Capitalized
-	bool IsFlexibleCase(const std::string& str)
+bool IsFlexibleCase(const std::string& str) {
-	{
   if (str.empty())
     return true;
 
@@ -43,10 +39,9 @@ namespace
   std::string rest = str.substr(1);
   return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper));
 }
-}
+}  // namespace
 
-namespace YAML
+namespace YAML {
-{
 bool convert<bool>::decode(const Node& node, bool& rhs) {
   if (!node.IsScalar())
     return false;
@@ -66,13 +61,13 @@ namespace YAML
   if (!IsFlexibleCase(node.Scalar()))
     return false;
 
-		for(unsigned i=0;i<sizeof(names)/sizeof(names[0]);i++) {
+  for (const auto& name : names) {
-			if(names[i].truename == tolower(node.Scalar())) {
+    if (name.truename == tolower(node.Scalar())) {
       rhs = true;
       return true;
     }
 
-			if(names[i].falsename == tolower(node.Scalar())) {
+    if (name.falsename == tolower(node.Scalar())) {
       rhs = false;
       return true;
     }
@@ -80,4 +75,4 @@ namespace YAML
 
   return false;
 }
-}
+}  // namespace YAML

src/directives.cpp

@@ -1,17 +1,10 @@
 #include "directives.h"
 
-namespace YAML
+namespace YAML {
-{
+Directives::Directives() : version{true, 1, 2}, tags{} {}
-	Directives::Directives()
-	{
-		// version
-		version.isDefault = true;
-		version.major = 1;
-		version.minor = 2;
-	}
 
-	const std::string Directives::TranslateTagHandle(const std::string& handle) const
+const std::string Directives::TranslateTagHandle(
-	{
+    const std::string& handle) const {
   std::map<std::string, std::string>::const_iterator it = tags.find(handle);
   if (it == tags.end()) {
     if (handle == "!!")
@@ -21,4 +14,4 @@ namespace YAML
 
   return it->second;
 }
-}
+}  // namespace YAML

src/directives.h

@@ -1,16 +1,16 @@
 #ifndef DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define DIRECTIVES_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 <map>
 
-namespace YAML
+namespace YAML {
-{
 struct Version {
   bool isDefault;
   int major, minor;

src/emit.cpp

@@ -3,27 +3,23 @@
 #include "yaml-cpp/emitter.h"
 #include "nodeevents.h"
 
-namespace YAML
+namespace YAML {
-{
+Emitter& operator<<(Emitter& out, const Node& node) {
-	Emitter& operator << (Emitter& out, const Node& node)
-	{
   EmitFromEvents emitFromEvents(out);
   NodeEvents events(node);
   events.Emit(emitFromEvents);
   return out;
 }
 
-	std::ostream& operator << (std::ostream& out, const Node& node)
+std::ostream& operator<<(std::ostream& out, const Node& node) {
-	{
   Emitter emitter(out);
   emitter << node;
   return out;
 }
 
-	std::string Dump(const Node& node)
+std::string Dump(const Node& node) {
-	{
   Emitter emitter;
   emitter << node;
   return emitter.c_str();
 }
-}
+}  // namespace YAML

src/emitfromevents.cpp

@@ -1,83 +1,99 @@
-#include "yaml-cpp/emitfromevents.h"
-#include "yaml-cpp/emitter.h"
-#include "yaml-cpp/null.h"
 #include <cassert>
 #include <sstream>
 
+#include "yaml-cpp/emitfromevents.h"
+#include "yaml-cpp/emitter.h"
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/null.h"
+
+namespace YAML {
+struct Mark;
+}  // namespace YAML
+
 namespace {
 std::string ToString(YAML::anchor_t anchor) {
   std::stringstream stream;
   stream << anchor;
   return stream.str();
 }
-}
+}  // namespace
 
-namespace YAML
+namespace YAML {
-{
+EmitFromEvents::EmitFromEvents(Emitter& emitter)
-	EmitFromEvents::EmitFromEvents(Emitter& emitter): m_emitter(emitter)
+    : m_emitter(emitter), m_stateStack{} {}
-	{
-	}
 
-	void EmitFromEvents::OnDocumentStart(const Mark&)
+void EmitFromEvents::OnDocumentStart(const Mark&) {}
-	{
-	}
 
-	void EmitFromEvents::OnDocumentEnd()
+void EmitFromEvents::OnDocumentEnd() {}
-	{
-	}
 
-	void EmitFromEvents::OnNull(const Mark&, anchor_t anchor)
+void EmitFromEvents::OnNull(const Mark&, anchor_t anchor) {
-	{
   BeginNode();
   EmitProps("", anchor);
   m_emitter << Null;
 }
 
-	void EmitFromEvents::OnAlias(const Mark&, anchor_t anchor)
+void EmitFromEvents::OnAlias(const Mark&, anchor_t anchor) {
-	{
   BeginNode();
   m_emitter << Alias(ToString(anchor));
 }
 
-	void EmitFromEvents::OnScalar(const Mark&, const std::string& tag, anchor_t anchor, const std::string& value)
+void EmitFromEvents::OnScalar(const Mark&, const std::string& tag,
-	{
+                              anchor_t anchor, const std::string& value) {
   BeginNode();
   EmitProps(tag, anchor);
   m_emitter << value;
 }
 
-	void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag, anchor_t anchor)
+void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag,
-	{
+                                     anchor_t anchor,
+                                     EmitterStyle::value style) {
   BeginNode();
   EmitProps(tag, anchor);
+  switch (style) {
+    case EmitterStyle::Block:
+      m_emitter << Block;
+      break;
+    case EmitterStyle::Flow:
+      m_emitter << Flow;
+      break;
+    default:
+      break;
+  }
   m_emitter << BeginSeq;
   m_stateStack.push(State::WaitingForSequenceEntry);
 }
 
-	void EmitFromEvents::OnSequenceEnd()
+void EmitFromEvents::OnSequenceEnd() {
-	{
   m_emitter << EndSeq;
   assert(m_stateStack.top() == State::WaitingForSequenceEntry);
   m_stateStack.pop();
 }
 
-	void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag, anchor_t anchor)
+void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag,
-	{
+                                anchor_t anchor, EmitterStyle::value style) {
   BeginNode();
   EmitProps(tag, anchor);
+  switch (style) {
+    case EmitterStyle::Block:
+      m_emitter << Block;
+      break;
+    case EmitterStyle::Flow:
+      m_emitter << Flow;
+      break;
+    default:
+      break;
+  }
   m_emitter << BeginMap;
   m_stateStack.push(State::WaitingForKey);
 }
 
-	void EmitFromEvents::OnMapEnd()
+void EmitFromEvents::OnMapEnd() {
-	{
   m_emitter << EndMap;
   assert(m_stateStack.top() == State::WaitingForKey);
   m_stateStack.pop();
 }
 
-	void EmitFromEvents::BeginNode()
+void EmitFromEvents::BeginNode() {
-	{
   if (m_stateStack.empty())
     return;
 
@@ -95,11 +111,10 @@ namespace YAML
   }
 }
 
-	void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor)
+void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) {
-	{
+  if (!tag.empty() && tag != "?" && tag != "!")
-		if(!tag.empty() && tag != "?")
     m_emitter << VerbatimTag(tag);
   if (anchor)
     m_emitter << Anchor(ToString(anchor));
 }
-}
+}  // namespace YAML

src/emitter.cpp

@@ -1,58 +1,44 @@
-#include "yaml-cpp/emitter.h"
-#include "emitterstate.h"
-#include "emitterutils.h"
-#include "indentation.h"
-#include "yaml-cpp/exceptions.h"
 #include <sstream>
 
-namespace YAML
+#include "emitterutils.h"
-{	
+#include "indentation.h"  // IWYU pragma: keep
-	Emitter::Emitter(): m_pState(new EmitterState)
+#include "yaml-cpp/emitter.h"
-	{
+#include "yaml-cpp/emitterdef.h"
-	}
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
 
-	Emitter::Emitter(std::ostream& stream): m_pState(new EmitterState), m_stream(stream)
+namespace YAML {
-	{
+class Binary;
-	}
+struct _Null;
 
-	Emitter::~Emitter()
+Emitter::Emitter() : m_pState(new EmitterState), m_stream{} {}
-	{
-	}
 
-	const char *Emitter::c_str() const
+Emitter::Emitter(std::ostream& stream)
-	{
+    : m_pState(new EmitterState), m_stream(stream) {}
-		return m_stream.str();
-	}
 
-    std::size_t Emitter::size() const
+Emitter::~Emitter() = default;
-	{
+
-		return m_stream.pos();
+const char* Emitter::c_str() const { return m_stream.str(); }
-	}
+
+std::size_t Emitter::size() const { return m_stream.pos(); }
 
 // state checking
-	bool Emitter::good() const
+bool Emitter::good() const { return m_pState->good(); }
-	{
-		return m_pState->good();
-	}
 
-	const std::string Emitter::GetLastError() const
+const std::string Emitter::GetLastError() const {
-	{
   return m_pState->GetLastError();
 }
 
 // global setters
-	bool Emitter::SetOutputCharset(EMITTER_MANIP value)
+bool Emitter::SetOutputCharset(EMITTER_MANIP value) {
-	{
   return m_pState->SetOutputCharset(value, FmtScope::Global);
 }
 
-	bool Emitter::SetStringFormat(EMITTER_MANIP value)
+bool Emitter::SetStringFormat(EMITTER_MANIP value) {
-	{
   return m_pState->SetStringFormat(value, FmtScope::Global);
 }
 
-	bool Emitter::SetBoolFormat(EMITTER_MANIP value)
+bool Emitter::SetBoolFormat(EMITTER_MANIP value) {
-	{
   bool ok = false;
   if (m_pState->SetBoolFormat(value, FmtScope::Global))
     ok = true;
@@ -63,18 +49,15 @@ namespace YAML
   return ok;
 }
 
-	bool Emitter::SetIntBase(EMITTER_MANIP value)
+bool Emitter::SetIntBase(EMITTER_MANIP value) {
-	{
   return m_pState->SetIntFormat(value, FmtScope::Global);
 }
 
-	bool Emitter::SetSeqFormat(EMITTER_MANIP value)
+bool Emitter::SetSeqFormat(EMITTER_MANIP value) {
-	{
   return m_pState->SetFlowType(GroupType::Seq, value, FmtScope::Global);
 }
 
-	bool Emitter::SetMapFormat(EMITTER_MANIP value)
+bool Emitter::SetMapFormat(EMITTER_MANIP value) {
-	{
   bool ok = false;
   if (m_pState->SetFlowType(GroupType::Map, value, FmtScope::Global))
     ok = true;
@@ -83,35 +66,29 @@ namespace YAML
   return ok;
 }
 
-	bool Emitter::SetIndent(unsigned n)
+bool Emitter::SetIndent(std::size_t n) {
-	{
   return m_pState->SetIndent(n, FmtScope::Global);
 }
 
-	bool Emitter::SetPreCommentIndent(unsigned n)
+bool Emitter::SetPreCommentIndent(std::size_t n) {
-	{
   return m_pState->SetPreCommentIndent(n, FmtScope::Global);
 }
 
-	bool Emitter::SetPostCommentIndent(unsigned n)
+bool Emitter::SetPostCommentIndent(std::size_t n) {
-	{
   return m_pState->SetPostCommentIndent(n, FmtScope::Global);
 }
 
-    bool Emitter::SetFloatPrecision(unsigned n)
+bool Emitter::SetFloatPrecision(std::size_t n) {
-    {
   return m_pState->SetFloatPrecision(n, FmtScope::Global);
 }
 
-    bool Emitter::SetDoublePrecision(unsigned n)
+bool Emitter::SetDoublePrecision(std::size_t n) {
-    {
   return m_pState->SetDoublePrecision(n, FmtScope::Global);
 }
 
 // SetLocalValue
 // . Either start/end a group, or set a modifier locally
-	Emitter& Emitter::SetLocalValue(EMITTER_MANIP value)
+Emitter& Emitter::SetLocalValue(EMITTER_MANIP value) {
-	{
   if (!good())
     return *this;
 
@@ -151,14 +128,12 @@ namespace YAML
   return *this;
 }
 
-	Emitter& Emitter::SetLocalIndent(const _Indent& indent)
+Emitter& Emitter::SetLocalIndent(const _Indent& indent) {
-	{
   m_pState->SetIndent(indent.value, FmtScope::Local);
   return *this;
 }
 
-    Emitter& Emitter::SetLocalPrecision(const _Precision& precision)
+Emitter& Emitter::SetLocalPrecision(const _Precision& precision) {
-    {
   if (precision.floatPrecision >= 0)
     m_pState->SetFloatPrecision(precision.floatPrecision, FmtScope::Local);
   if (precision.doublePrecision >= 0)
@@ -167,12 +142,11 @@ namespace YAML
 }
 
 // EmitBeginDoc
-	void Emitter::EmitBeginDoc()
+void Emitter::EmitBeginDoc() {
-	{
   if (!good())
     return;
 
-        if(m_pState->CurGroupType() != GroupType::None) {
+  if (m_pState->CurGroupType() != GroupType::NoType) {
     m_pState->SetError("Unexpected begin document");
     return;
   }
@@ -190,12 +164,11 @@ namespace YAML
 }
 
 // EmitEndDoc
-	void Emitter::EmitEndDoc()
+void Emitter::EmitEndDoc() {
-	{
   if (!good())
     return;
 
-        if(m_pState->CurGroupType() != GroupType::None) {
+  if (m_pState->CurGroupType() != GroupType::NoType) {
     m_pState->SetError("Unexpected begin document");
     return;
   }
@@ -211,8 +184,7 @@ namespace YAML
 }
 
 // EmitBeginSeq
-	void Emitter::EmitBeginSeq()
+void Emitter::EmitBeginSeq() {
-	{
   if (!good())
     return;
 
@@ -222,8 +194,7 @@ namespace YAML
 }
 
 // EmitEndSeq
-	void Emitter::EmitEndSeq()
+void Emitter::EmitEndSeq() {
-	{
   if (!good())
     return;
 
@@ -243,8 +214,7 @@ namespace YAML
 }
 
 // EmitBeginMap
-	void Emitter::EmitBeginMap()
+void Emitter::EmitBeginMap() {
-	{
   if (!good())
     return;
 
@@ -254,8 +224,7 @@ namespace YAML
 }
 
 // EmitEndMap
-	void Emitter::EmitEndMap()
+void Emitter::EmitEndMap() {
-	{
   if (!good())
     return;
 
@@ -275,27 +244,22 @@ namespace YAML
 }
 
 // EmitNewline
-	void Emitter::EmitNewline()
+void Emitter::EmitNewline() {
-	{
   if (!good())
     return;
 
-        PrepareNode(EmitterNodeType::None);
+  PrepareNode(EmitterNodeType::NoType);
   m_stream << "\n";
   m_pState->SetNonContent();
 }
 
-	bool Emitter::CanEmitNewline() const
+bool Emitter::CanEmitNewline() const { return true; }
-	{
-        return true;
-	}
 
 // Put the stream in a state so we can simply write the next node
 // E.g., if we're in a sequence, write the "- "
-    void Emitter::PrepareNode(EmitterNodeType::value child)
+void Emitter::PrepareNode(EmitterNodeType::value child) {
-    {
   switch (m_pState->CurGroupNodeType()) {
-            case EmitterNodeType::None:
+    case EmitterNodeType::NoType:
       PrepareTopNode(child);
       break;
     case EmitterNodeType::FlowSeq:
@@ -317,18 +281,15 @@ namespace YAML
   }
 }
 
-    void Emitter::PrepareTopNode(EmitterNodeType::value child)
+void Emitter::PrepareTopNode(EmitterNodeType::value child) {
-    {
+  if (child == EmitterNodeType::NoType)
-        if(child == EmitterNodeType::None)
     return;
 
-        if(m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0) {
+  if (m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0)
-            if(child != EmitterNodeType::None)
     EmitBeginDoc();
-        }
 
   switch (child) {
-            case EmitterNodeType::None:
+    case EmitterNodeType::NoType:
       break;
     case EmitterNodeType::Property:
     case EmitterNodeType::Scalar:
@@ -346,9 +307,8 @@ namespace YAML
   }
 }
 
-    void Emitter::FlowSeqPrepareNode(EmitterNodeType::value child)
+void Emitter::FlowSeqPrepareNode(EmitterNodeType::value child) {
-    {
+  const std::size_t lastIndent = m_pState->LastIndent();
-        const unsigned lastIndent = m_pState->LastIndent();
 
   if (!m_pState->HasBegunNode()) {
     if (m_stream.comment())
@@ -361,13 +321,15 @@ namespace YAML
   }
 
   switch (child) {
-            case EmitterNodeType::None:
+    case EmitterNodeType::NoType:
       break;
     case EmitterNodeType::Property:
     case EmitterNodeType::Scalar:
     case EmitterNodeType::FlowSeq:
     case EmitterNodeType::FlowMap:
-                SpaceOrIndentTo(m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, lastIndent);
+      SpaceOrIndentTo(
+          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+          lastIndent);
       break;
     case EmitterNodeType::BlockSeq:
     case EmitterNodeType::BlockMap:
@@ -376,12 +338,11 @@ namespace YAML
   }
 }
 
-    void Emitter::BlockSeqPrepareNode(EmitterNodeType::value child)
+void Emitter::BlockSeqPrepareNode(EmitterNodeType::value child) {
-    {
+  const std::size_t curIndent = m_pState->CurIndent();
-        const unsigned curIndent = m_pState->CurIndent();
+  const std::size_t nextIndent = curIndent + m_pState->CurGroupIndent();
-        const unsigned nextIndent = curIndent + m_pState->CurGroupIndent();
 
-        if(child == EmitterNodeType::None)
+  if (child == EmitterNodeType::NoType)
     return;
 
   if (!m_pState->HasBegunContent()) {
@@ -393,7 +354,7 @@ namespace YAML
   }
 
   switch (child) {
-            case EmitterNodeType::None:
+    case EmitterNodeType::NoType:
       break;
     case EmitterNodeType::Property:
     case EmitterNodeType::Scalar:
@@ -411,8 +372,7 @@ namespace YAML
   }
 }
 
-    void Emitter::FlowMapPrepareNode(EmitterNodeType::value child)
+void Emitter::FlowMapPrepareNode(EmitterNodeType::value child) {
-    {
   if (m_pState->CurGroupChildCount() % 2 == 0) {
     if (m_pState->GetMapKeyFormat() == LongKey)
       m_pState->SetLongKey();
@@ -429,9 +389,8 @@ namespace YAML
   }
 }
 
-    void Emitter::FlowMapPrepareLongKey(EmitterNodeType::value child)
+void Emitter::FlowMapPrepareLongKey(EmitterNodeType::value child) {
-    {
+  const std::size_t lastIndent = m_pState->LastIndent();
-        const unsigned lastIndent = m_pState->LastIndent();
 
   if (!m_pState->HasBegunNode()) {
     if (m_stream.comment())
@@ -444,13 +403,15 @@ namespace YAML
   }
 
   switch (child) {
-            case EmitterNodeType::None:
+    case EmitterNodeType::NoType:
       break;
     case EmitterNodeType::Property:
     case EmitterNodeType::Scalar:
     case EmitterNodeType::FlowSeq:
     case EmitterNodeType::FlowMap:
-                SpaceOrIndentTo(m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, lastIndent);
+      SpaceOrIndentTo(
+          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+          lastIndent);
       break;
     case EmitterNodeType::BlockSeq:
     case EmitterNodeType::BlockMap:
@@ -459,9 +420,8 @@ namespace YAML
   }
 }
 
-    void Emitter::FlowMapPrepareLongKeyValue(EmitterNodeType::value child)
+void Emitter::FlowMapPrepareLongKeyValue(EmitterNodeType::value child) {
-    {
+  const std::size_t lastIndent = m_pState->LastIndent();
-        const unsigned lastIndent = m_pState->LastIndent();
 
   if (!m_pState->HasBegunNode()) {
     if (m_stream.comment())
@@ -471,13 +431,15 @@ namespace YAML
   }
 
   switch (child) {
-            case EmitterNodeType::None:
+    case EmitterNodeType::NoType:
       break;
     case EmitterNodeType::Property:
     case EmitterNodeType::Scalar:
     case EmitterNodeType::FlowSeq:
     case EmitterNodeType::FlowMap:
-                SpaceOrIndentTo(m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, lastIndent);
+      SpaceOrIndentTo(
+          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+          lastIndent);
       break;
     case EmitterNodeType::BlockSeq:
     case EmitterNodeType::BlockMap:
@@ -486,9 +448,8 @@ namespace YAML
   }
 }
 
-    void Emitter::FlowMapPrepareSimpleKey(EmitterNodeType::value child)
+void Emitter::FlowMapPrepareSimpleKey(EmitterNodeType::value child) {
-    {
+  const std::size_t lastIndent = m_pState->LastIndent();
-        const unsigned lastIndent = m_pState->LastIndent();
 
   if (!m_pState->HasBegunNode()) {
     if (m_stream.comment())
@@ -501,13 +462,15 @@ namespace YAML
   }
 
   switch (child) {
-            case EmitterNodeType::None:
+    case EmitterNodeType::NoType:
       break;
     case EmitterNodeType::Property:
     case EmitterNodeType::Scalar:
     case EmitterNodeType::FlowSeq:
     case EmitterNodeType::FlowMap:
-                SpaceOrIndentTo(m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, lastIndent);
+      SpaceOrIndentTo(
+          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+          lastIndent);
       break;
     case EmitterNodeType::BlockSeq:
     case EmitterNodeType::BlockMap:
@@ -516,9 +479,8 @@ namespace YAML
   }
 }
 
-    void Emitter::FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child)
+void Emitter::FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child) {
-    {
+  const std::size_t lastIndent = m_pState->LastIndent();
-        const unsigned lastIndent = m_pState->LastIndent();
 
   if (!m_pState->HasBegunNode()) {
     if (m_stream.comment())
@@ -528,13 +490,15 @@ namespace YAML
   }
 
   switch (child) {
-            case EmitterNodeType::None:
+    case EmitterNodeType::NoType:
       break;
     case EmitterNodeType::Property:
     case EmitterNodeType::Scalar:
     case EmitterNodeType::FlowSeq:
     case EmitterNodeType::FlowMap:
-                SpaceOrIndentTo(m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, lastIndent);
+      SpaceOrIndentTo(
+          m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+          lastIndent);
       break;
     case EmitterNodeType::BlockSeq:
     case EmitterNodeType::BlockMap:
@@ -543,12 +507,12 @@ namespace YAML
   }
 }
 
-    void Emitter::BlockMapPrepareNode(EmitterNodeType::value child)
+void Emitter::BlockMapPrepareNode(EmitterNodeType::value child) {
-    {
   if (m_pState->CurGroupChildCount() % 2 == 0) {
     if (m_pState->GetMapKeyFormat() == LongKey)
       m_pState->SetLongKey();
-            if(child == EmitterNodeType::BlockSeq || child == EmitterNodeType::BlockMap)
+    if (child == EmitterNodeType::BlockSeq ||
+        child == EmitterNodeType::BlockMap)
       m_pState->SetLongKey();
 
     if (m_pState->CurGroupLongKey())
@@ -563,12 +527,11 @@ namespace YAML
   }
 }
 
-    void Emitter::BlockMapPrepareLongKey(EmitterNodeType::value child)
+void Emitter::BlockMapPrepareLongKey(EmitterNodeType::value child) {
-    {
+  const std::size_t curIndent = m_pState->CurIndent();
-        const unsigned curIndent = m_pState->CurIndent();
   const std::size_t childCount = m_pState->CurGroupChildCount();
 
-        if(child == EmitterNodeType::None)
+  if (child == EmitterNodeType::NoType)
     return;
 
   if (!m_pState->HasBegunContent()) {
@@ -583,7 +546,7 @@ namespace YAML
   }
 
   switch (child) {
-            case EmitterNodeType::None:
+    case EmitterNodeType::NoType:
       break;
     case EmitterNodeType::Property:
     case EmitterNodeType::Scalar:
@@ -597,11 +560,10 @@ namespace YAML
   }
 }
 
-    void Emitter::BlockMapPrepareLongKeyValue(EmitterNodeType::value child)
+void Emitter::BlockMapPrepareLongKeyValue(EmitterNodeType::value child) {
-    {
+  const std::size_t curIndent = m_pState->CurIndent();
-        const unsigned curIndent = m_pState->CurIndent();
 
-        if(child == EmitterNodeType::None)
+  if (child == EmitterNodeType::NoType)
     return;
 
   if (!m_pState->HasBegunContent()) {
@@ -611,7 +573,7 @@ namespace YAML
   }
 
   switch (child) {
-            case EmitterNodeType::None:
+    case EmitterNodeType::NoType:
       break;
     case EmitterNodeType::Property:
     case EmitterNodeType::Scalar:
@@ -624,12 +586,11 @@ namespace YAML
   }
 }
 
-    void Emitter::BlockMapPrepareSimpleKey(EmitterNodeType::value child)
+void Emitter::BlockMapPrepareSimpleKey(EmitterNodeType::value child) {
-    {
+  const std::size_t curIndent = m_pState->CurIndent();
-        const unsigned curIndent = m_pState->CurIndent();
   const std::size_t childCount = m_pState->CurGroupChildCount();
 
-        if(child == EmitterNodeType::None)
+  if (child == EmitterNodeType::NoType)
     return;
 
   if (!m_pState->HasBegunNode()) {
@@ -639,7 +600,7 @@ namespace YAML
   }
 
   switch (child) {
-            case EmitterNodeType::None:
+    case EmitterNodeType::NoType:
       break;
     case EmitterNodeType::Property:
     case EmitterNodeType::Scalar:
@@ -653,17 +614,16 @@ namespace YAML
   }
 }
 
-    void Emitter::BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child)
+void Emitter::BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child) {
-    {
+  const std::size_t curIndent = m_pState->CurIndent();
-        const unsigned curIndent = m_pState->CurIndent();
+  const std::size_t nextIndent = curIndent + m_pState->CurGroupIndent();
-        const unsigned nextIndent = curIndent + m_pState->CurGroupIndent();
 
   if (!m_pState->HasBegunNode()) {
     m_stream << ":";
   }
 
   switch (child) {
-            case EmitterNodeType::None:
+    case EmitterNodeType::NoType:
       break;
     case EmitterNodeType::Property:
     case EmitterNodeType::Scalar:
@@ -680,8 +640,7 @@ namespace YAML
 
 // SpaceOrIndentTo
 // . Prepares for some more content by proper spacing
-    void Emitter::SpaceOrIndentTo(bool requireSpace, unsigned indent)
+void Emitter::SpaceOrIndentTo(bool requireSpace, std::size_t indent) {
-    {
   if (m_stream.comment())
     m_stream << "\n";
   if (m_stream.col() > 0 && requireSpace)
@@ -689,8 +648,7 @@ namespace YAML
   m_stream << IndentTo(indent);
 }
 
-    void Emitter::PrepareIntegralStream(std::stringstream& stream) const
+void Emitter::PrepareIntegralStream(std::stringstream& stream) const {
-    {
 
   switch (m_pState->GetIntFormat()) {
     case Dec:
@@ -709,21 +667,19 @@ namespace YAML
   }
 }
 
-    void Emitter::StartedScalar()
+void Emitter::StartedScalar() { m_pState->StartedScalar(); }
-    {
-        m_pState->StartedScalar();
-    }
 
 // *******************************************************************************************
 // overloads of Write
 
-	Emitter& Emitter::Write(const std::string& str)
+Emitter& Emitter::Write(const std::string& str) {
-	{
   if (!good())
     return *this;
 
   const bool escapeNonAscii = m_pState->GetOutputCharset() == EscapeNonAscii;
-        const StringFormat::value strFormat = Utils::ComputeStringFormat(str, m_pState->GetStringFormat(), m_pState->CurGroupFlowType(), escapeNonAscii);
+  const StringFormat::value strFormat =
+      Utils::ComputeStringFormat(str, m_pState->GetStringFormat(),
+                                 m_pState->CurGroupFlowType(), escapeNonAscii);
 
   if (strFormat == StringFormat::Literal)
     m_pState->SetMapKeyFormat(YAML::LongKey, FmtScope::Local);
@@ -741,7 +697,8 @@ namespace YAML
       Utils::WriteDoubleQuotedString(m_stream, str, escapeNonAscii);
       break;
     case StringFormat::Literal:
-                Utils::WriteLiteralString(m_stream, str, m_pState->CurIndent() + m_pState->GetIndent());
+      Utils::WriteLiteralString(m_stream, str,
+                                m_pState->CurIndent() + m_pState->GetIndent());
       break;
   }
 
@@ -750,53 +707,64 @@ namespace YAML
   return *this;
 }
 
-    unsigned Emitter::GetFloatPrecision() const
+std::size_t Emitter::GetFloatPrecision() const {
-    {
   return m_pState->GetFloatPrecision();
 }
 
-    unsigned Emitter::GetDoublePrecision() const
+std::size_t Emitter::GetDoublePrecision() const {
-    {
   return m_pState->GetDoublePrecision();
 }
 
-	const char *Emitter::ComputeFullBoolName(bool b) const
+const char* Emitter::ComputeFullBoolName(bool b) const {
-	{
+  const EMITTER_MANIP mainFmt = (m_pState->GetBoolLengthFormat() == ShortBool
-		const EMITTER_MANIP mainFmt = (m_pState->GetBoolLengthFormat() == ShortBool ? YesNoBool : m_pState->GetBoolFormat());
+                                     ? YesNoBool
+                                     : m_pState->GetBoolFormat());
   const EMITTER_MANIP caseFmt = m_pState->GetBoolCaseFormat();
   switch (mainFmt) {
     case YesNoBool:
       switch (caseFmt) {
-					case UpperCase: return b ? "YES" : "NO";
+        case UpperCase:
-					case CamelCase: return b ? "Yes" : "No";
+          return b ? "YES" : "NO";
-					case LowerCase: return b ? "yes" : "no";
+        case CamelCase:
-					default: break;
+          return b ? "Yes" : "No";
+        case LowerCase:
+          return b ? "yes" : "no";
+        default:
+          break;
       }
       break;
     case OnOffBool:
       switch (caseFmt) {
-					case UpperCase: return b ? "ON" : "OFF";
+        case UpperCase:
-					case CamelCase: return b ? "On" : "Off";
+          return b ? "ON" : "OFF";
-					case LowerCase: return b ? "on" : "off";
+        case CamelCase:
-					default: break;
+          return b ? "On" : "Off";
+        case LowerCase:
+          return b ? "on" : "off";
+        default:
+          break;
       }
       break;
     case TrueFalseBool:
       switch (caseFmt) {
-					case UpperCase: return b ? "TRUE" : "FALSE";
+        case UpperCase:
-					case CamelCase: return b ? "True" : "False";
+          return b ? "TRUE" : "FALSE";
-					case LowerCase: return b ? "true" : "false";
+        case CamelCase:
-					default: break;
+          return b ? "True" : "False";
+        case LowerCase:
+          return b ? "true" : "false";
+        default:
+          break;
       }
       break;
     default:
       break;
   }
-		return b ? "y" : "n"; // should never get here, but it can't hurt to give these answers
+  return b ? "y" : "n";  // should never get here, but it can't hurt to give
+                         // these answers
 }
 
-	Emitter& Emitter::Write(bool b)
+Emitter& Emitter::Write(bool b) {
-	{
   if (!good())
     return *this;
 
@@ -813,8 +781,7 @@ namespace YAML
   return *this;
 }
 
-	Emitter& Emitter::Write(char ch)
+Emitter& Emitter::Write(char ch) {
-	{
   if (!good())
     return *this;
 
@@ -825,8 +792,7 @@ namespace YAML
   return *this;
 }
 
-	Emitter& Emitter::Write(const _Alias& alias)
+Emitter& Emitter::Write(const _Alias& alias) {
-	{
   if (!good())
     return *this;
 
@@ -847,8 +813,7 @@ namespace YAML
   return *this;
 }
 
-	Emitter& Emitter::Write(const _Anchor& anchor)
+Emitter& Emitter::Write(const _Anchor& anchor) {
-	{
   if (!good())
     return *this;
 
@@ -869,8 +834,7 @@ namespace YAML
   return *this;
 }
 
-	Emitter& Emitter::Write(const _Tag& tag)
+Emitter& Emitter::Write(const _Tag& tag) {
-	{
   if (!good())
     return *this;
 
@@ -899,29 +863,25 @@ namespace YAML
   return *this;
 }
 
-	void Emitter::EmitKindTag()
+void Emitter::EmitKindTag() { Write(LocalTag("")); }
-	{
-		Write(LocalTag(""));
-	}
 
-	Emitter& Emitter::Write(const _Comment& comment)
+Emitter& Emitter::Write(const _Comment& comment) {
-	{
   if (!good())
     return *this;
 
-        PrepareNode(EmitterNodeType::None);
+  PrepareNode(EmitterNodeType::NoType);
 
   if (m_stream.col() > 0)
     m_stream << Indentation(m_pState->GetPreCommentIndent());
-		Utils::WriteComment(m_stream, comment.content, m_pState->GetPostCommentIndent());
+  Utils::WriteComment(m_stream, comment.content,
+                      m_pState->GetPostCommentIndent());
 
   m_pState->SetNonContent();
 
   return *this;
 }
 
-	Emitter& Emitter::Write(const _Null& /*null*/)
+Emitter& Emitter::Write(const _Null& /*null*/) {
-	{
   if (!good())
     return *this;
 
@@ -934,8 +894,7 @@ namespace YAML
   return *this;
 }
 
-	Emitter& Emitter::Write(const Binary& binary)
+Emitter& Emitter::Write(const Binary& binary) {
-	{
   Write(SecondaryTag("binary"));
 
   if (!good())
@@ -947,5 +906,4 @@ namespace YAML
 
   return *this;
 }
-}
+}  // namespace YAML
-

src/emitterstate.cpp

@@ -1,37 +1,43 @@
-#include "emitterstate.h"
-#include "yaml-cpp/exceptions.h"
 #include <limits>
 
-namespace YAML
+#include "emitterstate.h"
-{
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
-	EmitterState::EmitterState(): m_isGood(true), m_curIndent(0), m_hasAnchor(false), m_hasTag(false), m_hasNonContent(false), m_docCount(0)
-	{
-		// set default global manipulators
-		m_charset.set(EmitNonAscii);
-		m_strFmt.set(Auto);
-		m_boolFmt.set(TrueFalseBool);
-		m_boolLengthFmt.set(LongBool);
-		m_boolCaseFmt.set(LowerCase);
-		m_intFmt.set(Dec);
-		m_indent.set(2);
-		m_preCommentIndent.set(2);
-		m_postCommentIndent.set(1);
-		m_seqFmt.set(Block);
-		m_mapFmt.set(Block);
-		m_mapKeyFmt.set(Auto);
-        m_floatPrecision.set(6);
-        m_doublePrecision.set(15);
-	}
 
-	EmitterState::~EmitterState()
+namespace YAML {
-	{
+EmitterState::EmitterState()
-	}
+    : m_isGood(true),
+      m_lastError{},
+      // default global manipulators
+      m_charset(EmitNonAscii),
+      m_strFmt(Auto),
+      m_boolFmt(TrueFalseBool),
+      m_boolLengthFmt(LongBool),
+      m_boolCaseFmt(LowerCase),
+      m_intFmt(Dec),
+      m_indent(2),
+      m_preCommentIndent(2),
+      m_postCommentIndent(1),
+      m_seqFmt(Block),
+      m_mapFmt(Block),
+      m_mapKeyFmt(Auto),
+      m_floatPrecision(std::numeric_limits<float>::max_digits10),
+      m_doublePrecision(std::numeric_limits<double>::max_digits10),
+      //
+      m_modifiedSettings{},
+      m_globalModifiedSettings{},
+      m_groups{},
+      m_curIndent(0),
+      m_hasAnchor(false),
+      m_hasTag(false),
+      m_hasNonContent(false),
+      m_docCount(0) {}
+
+EmitterState::~EmitterState() = default;
 
 // SetLocalValue
 // . We blindly tries to set all possible formatters to this value
 // . Only the ones that make sense will be accepted
-	void EmitterState::SetLocalValue(EMITTER_MANIP value)
+void EmitterState::SetLocalValue(EMITTER_MANIP value) {
-	{
   SetOutputCharset(value, FmtScope::Local);
   SetStringFormat(value, FmtScope::Local);
   SetBoolFormat(value, FmtScope::Local);
@@ -43,48 +49,39 @@ namespace YAML
   SetMapKeyFormat(value, FmtScope::Local);
 }
 
-    void EmitterState::SetAnchor()
+void EmitterState::SetAnchor() { m_hasAnchor = true; }
-    {
-        m_hasAnchor = true;
-    }
 
-    void EmitterState::SetTag()
+void EmitterState::SetTag() { m_hasTag = true; }
-    {
-        m_hasTag = true;
-    }
 
-    void EmitterState::SetNonContent()
+void EmitterState::SetNonContent() { m_hasNonContent = true; }
-    {
-        m_hasNonContent = true;
-    }
 
-    void EmitterState::SetLongKey()
+void EmitterState::SetLongKey() {
-    {
   assert(!m_groups.empty());
-        if(m_groups.empty())
+  if (m_groups.empty()) {
     return;
-        
-        assert(m_groups.top().type == GroupType::Map);
-        m_groups.top().longKey = true;
   }
 
-    void EmitterState::ForceFlow()
+  assert(m_groups.back()->type == GroupType::Map);
-    {
+  m_groups.back()->longKey = true;
+}
+
+void EmitterState::ForceFlow() {
   assert(!m_groups.empty());
-        if(m_groups.empty())
+  if (m_groups.empty()) {
     return;
-        
-        m_groups.top().flowType = FlowType::Flow;
   }
 
-    void EmitterState::StartedNode()
+  m_groups.back()->flowType = FlowType::Flow;
-    {
+}
+
+void EmitterState::StartedNode() {
   if (m_groups.empty()) {
     m_docCount++;
   } else {
-            m_groups.top().childCount++;
+    m_groups.back()->childCount++;
-            if(m_groups.top().childCount % 2 == 0)
+    if (m_groups.back()->childCount % 2 == 0) {
-                m_groups.top().longKey = false;
+      m_groups.back()->longKey = false;
+    }
   }
 
   m_hasAnchor = false;
@@ -92,8 +89,8 @@ namespace YAML
   m_hasNonContent = false;
 }
 
-    EmitterNodeType::value EmitterState::NextGroupType(GroupType::value type) const
+EmitterNodeType::value EmitterState::NextGroupType(
-    {
+    GroupType::value type) const {
   if (type == GroupType::Seq) {
     if (GetFlowType(type) == Block)
       return EmitterNodeType::BlockSeq;
@@ -108,69 +105,73 @@ namespace YAML
 
   // can't happen
   assert(false);
-        return EmitterNodeType::None;
+  return EmitterNodeType::NoType;
 }
 
-    void EmitterState::StartedDoc()
+void EmitterState::StartedDoc() {
-    {
   m_hasAnchor = false;
   m_hasTag = false;
   m_hasNonContent = false;
 }
 
-    void EmitterState::EndedDoc()
+void EmitterState::EndedDoc() {
-    {
   m_hasAnchor = false;
   m_hasTag = false;
   m_hasNonContent = false;
 }
 
-    void EmitterState::StartedScalar()
+void EmitterState::StartedScalar() {
-    {
   StartedNode();
   ClearModifiedSettings();
 }
 
-	void EmitterState::StartedGroup(GroupType::value type)
+void EmitterState::StartedGroup(GroupType::value type) {
-	{
   StartedNode();
 
-		const int lastGroupIndent = (m_groups.empty() ? 0 : m_groups.top().indent);
+  const std::size_t lastGroupIndent =
+      (m_groups.empty() ? 0 : m_groups.back()->indent);
   m_curIndent += lastGroupIndent;
 
-		std::auto_ptr<Group> pGroup(new Group(type));
+  // TODO: Create move constructors for settings types to simplify transfer
+  std::unique_ptr<Group> pGroup(new Group(type));
 
   // transfer settings (which last until this group is done)
-		pGroup->modifiedSettings = m_modifiedSettings;
+  //
+  // NB: if pGroup->modifiedSettings == m_modifiedSettings,
+  // m_modifiedSettings is not changed!
+  pGroup->modifiedSettings = std::move(m_modifiedSettings);
 
   // set up group
-        if(GetFlowType(type) == Block)
+  if (GetFlowType(type) == Block) {
     pGroup->flowType = FlowType::Block;
-        else
+  } else {
     pGroup->flowType = FlowType::Flow;
+  }
   pGroup->indent = GetIndent();
 
-		m_groups.push(pGroup);
+  m_groups.push_back(std::move(pGroup));
 }
 
-	void EmitterState::EndedGroup(GroupType::value type)
+void EmitterState::EndedGroup(GroupType::value type) {
-	{
   if (m_groups.empty()) {
-            if(type == GroupType::Seq)
+    if (type == GroupType::Seq) {
       return SetError(ErrorMsg::UNEXPECTED_END_SEQ);
-            else
+    } else {
       return SetError(ErrorMsg::UNEXPECTED_END_MAP);
     }
+  }
 
   // get rid of the current group
   {
-			std::auto_ptr<Group> pFinishedGroup = m_groups.pop();
+    std::unique_ptr<Group> pFinishedGroup = std::move(m_groups.back());
-			if(pFinishedGroup->type != type)
+    m_groups.pop_back();
+    if (pFinishedGroup->type != type) {
       return SetError(ErrorMsg::UNMATCHED_GROUP_TAG);
     }
+  }
 
   // reset old settings
-		unsigned lastIndent = (m_groups.empty() ? 0 : m_groups.top().indent);
+  std::size_t lastIndent = (m_groups.empty() ? 0 : m_groups.back()->indent);
   assert(m_curIndent >= lastIndent);
   m_curIndent -= lastIndent;
 
@@ -181,54 +182,46 @@ namespace YAML
   ClearModifiedSettings();
 }
 
-    EmitterNodeType::value EmitterState::CurGroupNodeType() const
+EmitterNodeType::value EmitterState::CurGroupNodeType() const {
-    {
+  if (m_groups.empty()) {
-        if(m_groups.empty())
+    return EmitterNodeType::NoType;
-            return EmitterNodeType::None;
-        
-        return m_groups.top().NodeType();
   }
 
-    GroupType::value EmitterState::CurGroupType() const
+  return m_groups.back()->NodeType();
-	{
-        return m_groups.empty() ? GroupType::None : m_groups.top().type;
 }
 
-    FlowType::value EmitterState::CurGroupFlowType() const
+GroupType::value EmitterState::CurGroupType() const {
-	{
+  return m_groups.empty() ? GroupType::NoType : m_groups.back()->type;
-        return m_groups.empty() ? FlowType::None : m_groups.top().flowType;
 }
 
-    int EmitterState::CurGroupIndent() const
+FlowType::value EmitterState::CurGroupFlowType() const {
-    {
+  return m_groups.empty() ? FlowType::NoType : m_groups.back()->flowType;
-        return m_groups.empty() ? 0 : m_groups.top().indent;
 }
 
-    std::size_t EmitterState::CurGroupChildCount() const
+std::size_t EmitterState::CurGroupIndent() const {
-    {
+  return m_groups.empty() ? 0 : m_groups.back()->indent;
-        return m_groups.empty() ? m_docCount : m_groups.top().childCount;
 }
 
-    bool EmitterState::CurGroupLongKey() const
+std::size_t EmitterState::CurGroupChildCount() const {
-    {
+  return m_groups.empty() ? m_docCount : m_groups.back()->childCount;
-        return m_groups.empty() ? false : m_groups.top().longKey;
 }
 
-    int EmitterState::LastIndent() const
+bool EmitterState::CurGroupLongKey() const {
-    {
+  return m_groups.empty() ? false : m_groups.back()->longKey;
-        if(m_groups.size() <= 1)
+}
+
+std::size_t EmitterState::LastIndent() const {
+  if (m_groups.size() <= 1) {
     return 0;
-        
-        return m_curIndent - m_groups.top(-1).indent;
   }
 
-	void EmitterState::ClearModifiedSettings()
+  return m_curIndent - m_groups[m_groups.size() - 2]->indent;
-	{
-		m_modifiedSettings.clear();
 }
 
-	bool EmitterState::SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope)
+void EmitterState::ClearModifiedSettings() { m_modifiedSettings.clear(); }
-	{
+
+bool EmitterState::SetOutputCharset(EMITTER_MANIP value,
+                                    FmtScope::value scope) {
   switch (value) {
     case EmitNonAscii:
     case EscapeNonAscii:
@@ -239,8 +232,7 @@ namespace YAML
   }
 }
 
-	bool EmitterState::SetStringFormat(EMITTER_MANIP value, FmtScope::value scope)
+bool EmitterState::SetStringFormat(EMITTER_MANIP value, FmtScope::value scope) {
-	{
   switch (value) {
     case Auto:
     case SingleQuoted:
@@ -253,8 +245,7 @@ namespace YAML
   }
 }
 
-	bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope)
+bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope) {
-	{
   switch (value) {
     case OnOffBool:
     case TrueFalseBool:
@@ -266,8 +257,8 @@ namespace YAML
   }
 }
 
-	bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope)
+bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value,
-	{
+                                       FmtScope::value scope) {
   switch (value) {
     case LongBool:
     case ShortBool:
@@ -278,8 +269,8 @@ namespace YAML
   }
 }
 
-	bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope)
+bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value,
-	{
+                                     FmtScope::value scope) {
   switch (value) {
     case UpperCase:
     case LowerCase:
@@ -291,8 +282,7 @@ namespace YAML
   }
 }
 
-	bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope::value scope)
+bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope::value scope) {
-	{
   switch (value) {
     case Dec:
     case Hex:
@@ -304,8 +294,7 @@ namespace YAML
   }
 }
 
-	bool EmitterState::SetIndent(unsigned value, FmtScope::value scope)
+bool EmitterState::SetIndent(std::size_t value, FmtScope::value scope) {
-	{
   if (value <= 1)
     return false;
 
@@ -313,8 +302,8 @@ namespace YAML
   return true;
 }
 
-	bool EmitterState::SetPreCommentIndent(unsigned value, FmtScope::value scope)
+bool EmitterState::SetPreCommentIndent(std::size_t value,
-	{
+                                       FmtScope::value scope) {
   if (value == 0)
     return false;
 
@@ -322,8 +311,8 @@ namespace YAML
   return true;
 }
 
-	bool EmitterState::SetPostCommentIndent(unsigned value, FmtScope::value scope)
+bool EmitterState::SetPostCommentIndent(std::size_t value,
-	{
+                                        FmtScope::value scope) {
   if (value == 0)
     return false;
 
@@ -331,8 +320,8 @@ namespace YAML
   return true;
 }
 
-	bool EmitterState::SetFlowType(GroupType::value groupType, EMITTER_MANIP value, FmtScope::value scope)
+bool EmitterState::SetFlowType(GroupType::value groupType, EMITTER_MANIP value,
-	{
+                               FmtScope::value scope) {
   switch (value) {
     case Block:
     case Flow:
@@ -343,8 +332,7 @@ namespace YAML
   }
 }
 
-	EMITTER_MANIP EmitterState::GetFlowType(GroupType::value groupType) const
+EMITTER_MANIP EmitterState::GetFlowType(GroupType::value groupType) const {
-	{
   // force flow style if we're currently in a flow
   if (CurGroupFlowType() == FlowType::Flow)
     return Flow;
@@ -353,8 +341,7 @@ namespace YAML
   return (groupType == GroupType::Seq ? m_seqFmt.get() : m_mapFmt.get());
 }
 
-	bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope)
+bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope) {
-	{
   switch (value) {
     case Auto:
     case LongKey:
@@ -365,20 +352,18 @@ namespace YAML
   }
 }
 
-    bool EmitterState::SetFloatPrecision(int value, FmtScope::value scope)
+bool EmitterState::SetFloatPrecision(std::size_t value, FmtScope::value scope) {
-    {
+  if (value > std::numeric_limits<float>::max_digits10)
-        if(value < 0 || value > std::numeric_limits<float>::digits10)
     return false;
   _Set(m_floatPrecision, value, scope);
   return true;
 }
 
-    bool EmitterState::SetDoublePrecision(int value, FmtScope::value scope)
+bool EmitterState::SetDoublePrecision(std::size_t value,
-    {
+                                      FmtScope::value scope) {
-        if(value < 0 || value > std::numeric_limits<double>::digits10)
+  if (value > std::numeric_limits<double>::max_digits10)
     return false;
   _Set(m_doublePrecision, value, scope);
   return true;
 }
-}
+}  // namespace YAML
-

src/emitterstate.h

@@ -1,29 +1,34 @@
 #ifndef EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTERSTATE_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 "ptr_stack.h"
 #include "setting.h"
 #include "yaml-cpp/emitterdef.h"
 #include "yaml-cpp/emittermanip.h"
+
 #include <cassert>
-#include <vector>
-#include <stack>
 #include <memory>
+#include <stack>
 #include <stdexcept>
+#include <vector>
 
-namespace YAML
+namespace YAML {
-{
+struct FmtScope {
-	struct FmtScope { enum value { Local, Global }; };
+  enum value { Local, Global };
-	struct GroupType { enum value { None, Seq, Map }; };
+};
-	struct FlowType { enum value { None, Flow, Block }; };
+struct GroupType {
+  enum value { NoType, Seq, Map };
+};
+struct FlowType {
+  enum value { NoType, Flow, Block };
+};
 
-	class EmitterState
+class EmitterState {
-	{
  public:
   EmitterState();
   ~EmitterState();
@@ -31,7 +36,10 @@ namespace YAML
   // basic state checking
   bool good() const { return m_isGood; }
   const std::string GetLastError() const { return m_lastError; }
-		void SetError(const std::string& error) { m_isGood = false; m_lastError = error; }
+  void SetError(const std::string& error) {
+    m_isGood = false;
+    m_lastError = error;
+  }
 
   // node handling
   void SetAnchor();
@@ -50,15 +58,17 @@ namespace YAML
 
   GroupType::value CurGroupType() const;
   FlowType::value CurGroupFlowType() const;
-        int CurGroupIndent() const;
+  std::size_t CurGroupIndent() const;
   std::size_t CurGroupChildCount() const;
   bool CurGroupLongKey() const;
 
-        int LastIndent() const;
+  std::size_t LastIndent() const;
-		int CurIndent() const { return m_curIndent; }
+  std::size_t CurIndent() const { return m_curIndent; }
   bool HasAnchor() const { return m_hasAnchor; }
   bool HasTag() const { return m_hasTag; }
-        bool HasBegunNode() const { return m_hasAnchor || m_hasTag || m_hasNonContent; }
+  bool HasBegunNode() const {
+    return m_hasAnchor || m_hasTag || m_hasNonContent;
+  }
   bool HasBegunContent() const { return m_hasAnchor || m_hasTag; }
 
   void ClearModifiedSettings();
@@ -84,24 +94,25 @@ namespace YAML
   bool SetIntFormat(EMITTER_MANIP value, FmtScope::value scope);
   EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); }
 
-		bool SetIndent(unsigned value, FmtScope::value scope);
+  bool SetIndent(std::size_t value, FmtScope::value scope);
-		int GetIndent() const { return m_indent.get(); }
+  std::size_t GetIndent() const { return m_indent.get(); }
 
-		bool SetPreCommentIndent(unsigned value, FmtScope::value scope);
+  bool SetPreCommentIndent(std::size_t value, FmtScope::value scope);
-		int GetPreCommentIndent() const { return m_preCommentIndent.get(); }
+  std::size_t GetPreCommentIndent() const { return m_preCommentIndent.get(); }
-		bool SetPostCommentIndent(unsigned value, FmtScope::value scope);
+  bool SetPostCommentIndent(std::size_t value, FmtScope::value scope);
-		int GetPostCommentIndent() const { return m_postCommentIndent.get(); }
+  std::size_t GetPostCommentIndent() const { return m_postCommentIndent.get(); }
 
-		bool SetFlowType(GroupType::value groupType, EMITTER_MANIP value, FmtScope::value scope);
+  bool SetFlowType(GroupType::value groupType, EMITTER_MANIP value,
+                   FmtScope::value scope);
   EMITTER_MANIP GetFlowType(GroupType::value groupType) const;
 
   bool SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope);
   EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); }
 
-        bool SetFloatPrecision(int value, FmtScope::value scope);
+  bool SetFloatPrecision(std::size_t value, FmtScope::value scope);
-        unsigned GetFloatPrecision() const { return m_floatPrecision.get(); }
+  std::size_t GetFloatPrecision() const { return m_floatPrecision.get(); }
-        bool SetDoublePrecision(int value, FmtScope::value scope);
+  bool SetDoublePrecision(std::size_t value, FmtScope::value scope);
-        unsigned GetDoublePrecision() const { return m_doublePrecision.get(); }
+  std::size_t GetDoublePrecision() const { return m_doublePrecision.get(); }
 
  private:
   template <typename T>
@@ -121,23 +132,29 @@ namespace YAML
   Setting<EMITTER_MANIP> m_boolLengthFmt;
   Setting<EMITTER_MANIP> m_boolCaseFmt;
   Setting<EMITTER_MANIP> m_intFmt;
-		Setting<unsigned> m_indent;
+  Setting<std::size_t> m_indent;
-		Setting<unsigned> m_preCommentIndent, m_postCommentIndent;
+  Setting<std::size_t> m_preCommentIndent, m_postCommentIndent;
   Setting<EMITTER_MANIP> m_seqFmt;
   Setting<EMITTER_MANIP> m_mapFmt;
   Setting<EMITTER_MANIP> m_mapKeyFmt;
-        Setting<int> m_floatPrecision;
+  Setting<std::size_t> m_floatPrecision;
-        Setting<int> m_doublePrecision;
+  Setting<std::size_t> m_doublePrecision;
 
   SettingChanges m_modifiedSettings;
   SettingChanges m_globalModifiedSettings;
 
   struct Group {
-			explicit Group(GroupType::value type_): type(type_), indent(0), childCount(0), longKey(false) {}
+    explicit Group(GroupType::value type_)
+        : type(type_),
+          flowType{},
+          indent(0),
+          childCount(0),
+          longKey(false),
+          modifiedSettings{} {}
 
     GroupType::value type;
     FlowType::value flowType;
-			int indent;
+    std::size_t indent;
     std::size_t childCount;
     bool longKey;
 
@@ -158,12 +175,12 @@ namespace YAML
 
       // can't get here
       assert(false);
-                return EmitterNodeType::None;
+      return EmitterNodeType::NoType;
     }
   };
 
-		ptr_stack<Group> m_groups;
+  std::vector<std::unique_ptr<Group>> m_groups;
-		unsigned m_curIndent;
+  std::size_t m_curIndent;
   bool m_hasAnchor;
   bool m_hasTag;
   bool m_hasNonContent;
@@ -178,13 +195,14 @@ namespace YAML
       break;
     case FmtScope::Global:
       fmt.set(value);
-				m_globalModifiedSettings.push(fmt.set(value));  // this pushes an identity set, so when we restore,
+      m_globalModifiedSettings.push(
+          fmt.set(value));  // this pushes an identity set, so when we restore,
       // it restores to the value here, and not the previous one
       break;
     default:
       assert(false);
   }
 }
-}
+}  // namespace YAML
 
 #endif  // EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/emitterutils.cpp

@@ -1,46 +1,61 @@
+#include <iomanip>
+#include <sstream>
+
 #include "emitterutils.h"
 #include "exp.h"
 #include "indentation.h"
-#include "yaml-cpp/binary.h"
+#include "regex_yaml.h"
-#include "yaml-cpp/exceptions.h"
+#include "regeximpl.h"
 #include "stringsource.h"
-#include <sstream>
+#include "yaml-cpp/binary.h"  // IWYU pragma: keep
-#include <iomanip>
+#include "yaml-cpp/null.h"
+#include "yaml-cpp/ostream_wrapper.h"
 
-namespace YAML
+namespace YAML {
-{
+namespace Utils {
-	namespace Utils
-	{
 namespace {
 enum { REPLACEMENT_CHARACTER = 0xFFFD };
 
 bool IsAnchorChar(int ch) {  // test for ns-anchor-char
   switch (ch) {
-					case ',': case '[': case ']': case '{': case '}': // c-flow-indicator
+    case ',':
-					case ' ': case '\t': // s-white
+    case '[':
+    case ']':
+    case '{':
+    case '}':  // c-flow-indicator
+    case ' ':
+    case '\t':    // s-white
     case 0xFEFF:  // c-byte-order-mark
-					case 0xA: case 0xD: // b-char
+    case 0xA:
+    case 0xD:  // b-char
       return false;
     case 0x85:
       return true;
   }
 
-				if (ch < 0x20)
+  if (ch < 0x20) {
     return false;
+  }
 
-				if (ch < 0x7E)
+  if (ch < 0x7E) {
     return true;
+  }
 
-				if (ch < 0xA0)
+  if (ch < 0xA0) {
     return false;
-				if (ch >= 0xD800 && ch <= 0xDFFF)
+  }
+  if (ch >= 0xD800 && ch <= 0xDFFF) {
     return false;
-				if ((ch & 0xFFFE) == 0xFFFE)
+  }
+  if ((ch & 0xFFFE) == 0xFFFE) {
     return false;
-				if ((ch >= 0xFDD0) && (ch <= 0xFDEF))
+  }
+  if ((ch >= 0xFDD0) && (ch <= 0xFDEF)) {
     return false;
-				if (ch > 0x10FFFF)
+  }
+  if (ch > 0x10FFFF) {
     return false;
+  }
 
   return true;
 }
@@ -48,9 +63,17 @@ namespace YAML
 int Utf8BytesIndicated(char ch) {
   int byteVal = static_cast<unsigned char>(ch);
   switch (byteVal >> 4) {
-					case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
       return 1;
-					case 12: case 13:
+    case 12:
+    case 13:
       return 2;
     case 14:
       return 3;
@@ -61,11 +84,11 @@ namespace YAML
   }
 }
 
-			bool IsTrailingByte(char ch) {
+bool IsTrailingByte(char ch) { return (ch & 0xC0) == 0x80; }
-				return (ch & 0xC0) == 0x80;
-			}
 
-			bool GetNextCodePointAndAdvance(int& codePoint, std::string::const_iterator& first, std::string::const_iterator last) {
+bool GetNextCodePointAndAdvance(int& codePoint,
+                                std::string::const_iterator& first,
+                                std::string::const_iterator last) {
   if (first == last)
     return false;
 
@@ -111,12 +134,12 @@ namespace YAML
   if (codePoint < 0 || codePoint > 0x10FFFF) {
     codePoint = REPLACEMENT_CHARACTER;
   }
-				if (codePoint < 0x7F) {
+  if (codePoint <= 0x7F) {
     out << static_cast<char>(codePoint);
-				} else if (codePoint < 0x7FF) {
+  } else if (codePoint <= 0x7FF) {
     out << static_cast<char>(0xC0 | (codePoint >> 6))
         << static_cast<char>(0x80 | (codePoint & 0x3F));
-				} else if (codePoint < 0xFFFF) {
+  } else if (codePoint <= 0xFFFF) {
     out << static_cast<char>(0xE0 | (codePoint >> 12))
         << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F))
         << static_cast<char>(0x80 | (codePoint & 0x3F));
@@ -128,60 +151,77 @@ namespace YAML
   }
 }
 
-			bool IsValidPlainScalar(const std::string& str, FlowType::value flowType, bool allowOnlyAscii) {
+bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
-				if(str.empty())
+                        bool allowOnlyAscii) {
+  // check against null
+  if (IsNullString(str)) {
     return false;
+  }
 
-				// first check the start
+  // check the start
-				const RegEx& start = (flowType == FlowType::Flow ? Exp::PlainScalarInFlow() : Exp::PlainScalar());
+  const RegEx& start = (flowType == FlowType::Flow ? Exp::PlainScalarInFlow()
-				if(!start.Matches(str))
+                                                   : Exp::PlainScalar());
+  if (!start.Matches(str)) {
     return false;
+  }
 
-				// and check the end for plain whitespace (which can't be faithfully kept in a plain scalar)
+  // and check the end for plain whitespace (which can't be faithfully kept in a
-				if(!str.empty() && *str.rbegin() == ' ')
+  // plain scalar)
+  if (!str.empty() && *str.rbegin() == ' ') {
     return false;
+  }
 
   // then check until something is disallowed
-				const RegEx& disallowed = (flowType == FlowType::Flow ? Exp::EndScalarInFlow() : Exp::EndScalar())
+  static const RegEx& disallowed_flow =
-				                          || (Exp::BlankOrBreak() + Exp::Comment())
+      Exp::EndScalarInFlow() | (Exp::BlankOrBreak() + Exp::Comment()) |
-				                          || Exp::NotPrintable()
+      Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() |
-				                          || Exp::Utf8_ByteOrderMark()
+      Exp::Tab();
-				                          || Exp::Break()
+  static const RegEx& disallowed_block =
-				                          || Exp::Tab();
+      Exp::EndScalar() | (Exp::BlankOrBreak() + Exp::Comment()) |
+      Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() |
+      Exp::Tab();
+  const RegEx& disallowed =
+      flowType == FlowType::Flow ? disallowed_flow : disallowed_block;
+
   StringCharSource buffer(str.c_str(), str.size());
   while (buffer) {
-					if(disallowed.Matches(buffer))
+    if (disallowed.Matches(buffer)) {
       return false;
-					if(allowOnlyAscii && (0x80 <= static_cast<unsigned char>(buffer[0]))) 
+    }
+    if (allowOnlyAscii && (0x80 <= static_cast<unsigned char>(buffer[0]))) {
       return false;
+    }
     ++buffer;
   }
 
   return true;
 }
 
-			bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii)
+bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) {
-            {
   // TODO: check for non-printable characters?
-                for(std::size_t i=0;i<str.size();i++) {
+  for (char ch : str) {
-                    if(escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i])))
+    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch))) {
       return false;
-                    if(str[i] == '\n')
+    }
+    if (ch == '\n') {
       return false;
     }
+  }
   return true;
 }
 
-            bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType, bool escapeNonAscii)
+bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType,
-            {
+                          bool escapeNonAscii) {
-                if(flowType == FlowType::Flow)
+  if (flowType == FlowType::Flow) {
     return false;
+  }
 
   // TODO: check for non-printable characters?
-                for(std::size_t i=0;i<str.size();i++) {
+  for (char ch : str) {
-                    if(escapeNonAscii && (0x80 <= static_cast<unsigned char>(str[i])))
+    if (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch))) {
       return false;
     }
+  }
   return true;
 }
 
@@ -209,34 +249,38 @@ namespace YAML
 bool WriteAliasName(ostream_wrapper& out, const std::string& str) {
   int codePoint;
   for (std::string::const_iterator i = str.begin();
-					GetNextCodePointAndAdvance(codePoint, i, str.end());
+       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
-					)
+    if (!IsAnchorChar(codePoint)) {
-				{
-					if (!IsAnchorChar(codePoint))
       return false;
+    }
 
     WriteCodePoint(out, codePoint);
   }
   return true;
 }
-		}
+}  // namespace
 
-        StringFormat::value ComputeStringFormat(const std::string& str, EMITTER_MANIP strFormat, FlowType::value flowType, bool escapeNonAscii)
+StringFormat::value ComputeStringFormat(const std::string& str,
-        {
+                                        EMITTER_MANIP strFormat,
+                                        FlowType::value flowType,
+                                        bool escapeNonAscii) {
   switch (strFormat) {
     case Auto:
-                    if(IsValidPlainScalar(str, flowType, escapeNonAscii))
+      if (IsValidPlainScalar(str, flowType, escapeNonAscii)) {
         return StringFormat::Plain;
+      }
       return StringFormat::DoubleQuoted;
     case SingleQuoted:
-                    if(IsValidSingleQuotedScalar(str, escapeNonAscii))
+      if (IsValidSingleQuotedScalar(str, escapeNonAscii)) {
         return StringFormat::SingleQuoted;
+      }
       return StringFormat::DoubleQuoted;
     case DoubleQuoted:
       return StringFormat::DoubleQuoted;
     case Literal:
-                    if(IsValidLiteralScalar(str, flowType, escapeNonAscii))
+      if (IsValidLiteralScalar(str, flowType, escapeNonAscii)) {
         return StringFormat::Literal;
+      }
       return StringFormat::DoubleQuoted;
     default:
       break;
@@ -245,86 +289,102 @@ namespace YAML
   return StringFormat::DoubleQuoted;
 }
 
-		bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str)
+bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str) {
-		{
   out << "'";
   int codePoint;
   for (std::string::const_iterator i = str.begin();
-				GetNextCodePointAndAdvance(codePoint, i, str.end());
+       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
-				) 
+    if (codePoint == '\n') {
-			{
+      return false;  // We can't handle a new line and the attendant indentation
-				if (codePoint == '\n')
+                     // yet
-					return false;  // We can't handle a new line and the attendant indentation yet
+    }
 
-				if (codePoint == '\'')
+    if (codePoint == '\'') {
       out << "''";
-				else
+    } else {
       WriteCodePoint(out, codePoint);
     }
+  }
   out << "'";
   return true;
 }
 
-		bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, bool escapeNonAscii)
+bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
-		{
+                             bool escapeNonAscii) {
   out << "\"";
   int codePoint;
   for (std::string::const_iterator i = str.begin();
-				GetNextCodePointAndAdvance(codePoint, i, str.end());
+       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
-				) 
-			{
     switch (codePoint) {
-                    case '\"': out << "\\\""; break;
+      case '\"':
-                    case '\\': out << "\\\\"; break;
+        out << "\\\"";
-                    case '\n': out << "\\n"; break;
+        break;
-                    case '\t': out << "\\t"; break;
+      case '\\':
-                    case '\r': out << "\\r"; break;
+        out << "\\\\";
-                    case '\b': out << "\\b"; break;
+        break;
+      case '\n':
+        out << "\\n";
+        break;
+      case '\t':
+        out << "\\t";
+        break;
+      case '\r':
+        out << "\\r";
+        break;
+      case '\b':
+        out << "\\b";
+        break;
       default:
-                        if(codePoint < 0x20 || (codePoint >= 0x80 && codePoint <= 0xA0)) // Control characters and non-breaking space
+        if (codePoint < 0x20 ||
+            (codePoint >= 0x80 &&
+             codePoint <= 0xA0)) {  // Control characters and non-breaking space
           WriteDoubleQuoteEscapeSequence(out, codePoint);
-                        else if (codePoint == 0xFEFF) // Byte order marks (ZWNS) should be escaped (YAML 1.2, sec. 5.2)	
+        } else if (codePoint == 0xFEFF) {  // Byte order marks (ZWNS) should be
+                                           // escaped (YAML 1.2, sec. 5.2)
           WriteDoubleQuoteEscapeSequence(out, codePoint);
-                        else if (escapeNonAscii && codePoint > 0x7E)
+        } else if (escapeNonAscii && codePoint > 0x7E) {
           WriteDoubleQuoteEscapeSequence(out, codePoint);
-                        else
+        } else {
           WriteCodePoint(out, codePoint);
         }
     }
+  }
   out << "\"";
   return true;
 }
 
-		bool WriteLiteralString(ostream_wrapper& out, const std::string& str, int indent)
+bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
-		{
+                        std::size_t indent) {
   out << "|\n";
   out << IndentTo(indent);
   int codePoint;
   for (std::string::const_iterator i = str.begin();
-				GetNextCodePointAndAdvance(codePoint, i, str.end());
+       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
-				)
+    if (codePoint == '\n') {
-			{
-				if (codePoint == '\n')
       out << "\n" << IndentTo(indent);
-				else
+    } else {
       WriteCodePoint(out, codePoint);
     }
+  }
   return true;
 }
 
-		bool WriteChar(ostream_wrapper& out, char ch)
+bool WriteChar(ostream_wrapper& out, char ch) {
-		{
+  if (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z')) {
-			if(('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z'))
     out << ch;
-			else if((0x20 <= ch && ch <= 0x7e) || ch == ' ')
+  } else if (ch == '\"') {
-				out << "\"" << ch << "\"";
+    out << "\"\\\"\"";
-			else if(ch == '\t')
+  } else if (ch == '\t') {
     out << "\"\\t\"";
-			else if(ch == '\n')
+  } else if (ch == '\n') {
     out << "\"\\n\"";
-			else if(ch == '\b')
+  } else if (ch == '\b') {
     out << "\"\\b\"";
-			else {
+  } else if (ch == '\\') {
+    out << "\"\\\\\"";
+  } else if (0x20 <= ch && ch <= 0x7e) {
+    out << "\"" << ch << "\"";
+  } else {
     out << "\"";
     WriteDoubleQuoteEscapeSequence(out, ch);
     out << "\"";
@@ -332,18 +392,17 @@ namespace YAML
   return true;
 }
 
-		bool WriteComment(ostream_wrapper& out, const std::string& str, int postCommentIndent)
+bool WriteComment(ostream_wrapper& out, const std::string& str,
-		{
+                  std::size_t postCommentIndent) {
-			const unsigned curIndent = out.col();
+  const std::size_t curIndent = out.col();
   out << "#" << Indentation(postCommentIndent);
   out.set_comment();
   int codePoint;
   for (std::string::const_iterator i = str.begin();
-				GetNextCodePointAndAdvance(codePoint, i, str.end());
+       GetNextCodePointAndAdvance(codePoint, i, str.end());) {
-				)
-			{
     if (codePoint == '\n') {
-					out << "\n" << IndentTo(curIndent) << "#" << Indentation(postCommentIndent);
+      out << "\n"
+          << IndentTo(curIndent) << "#" << Indentation(postCommentIndent);
       out.set_comment();
     } else {
       WriteCodePoint(out, codePoint);
@@ -352,46 +411,46 @@ namespace YAML
   return true;
 }
 
-		bool WriteAlias(ostream_wrapper& out, const std::string& str)
+bool WriteAlias(ostream_wrapper& out, const std::string& str) {
-		{
   out << "*";
   return WriteAliasName(out, str);
 }
 
-		bool WriteAnchor(ostream_wrapper& out, const std::string& str)
+bool WriteAnchor(ostream_wrapper& out, const std::string& str) {
-		{
   out << "&";
   return WriteAliasName(out, str);
 }
 
-		bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim)
+bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim) {
-		{
   out << (verbatim ? "!<" : "!");
   StringCharSource buffer(str.c_str(), str.size());
   const RegEx& reValid = verbatim ? Exp::URI() : Exp::Tag();
   while (buffer) {
     int n = reValid.Match(buffer);
-				if(n <= 0)
+    if (n <= 0) {
       return false;
+    }
 
     while (--n >= 0) {
       out << buffer[0];
       ++buffer;
     }
   }
-			if (verbatim)
+  if (verbatim) {
     out << ">";
+  }
   return true;
 }
 
-		bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix, const std::string& tag)
+bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix,
-		{
+                        const std::string& tag) {
   out << "!";
   StringCharSource prefixBuffer(prefix.c_str(), prefix.size());
   while (prefixBuffer) {
     int n = Exp::URI().Match(prefixBuffer);
-				if(n <= 0)
+    if (n <= 0) {
       return false;
+    }
 
     while (--n >= 0) {
       out << prefixBuffer[0];
@@ -403,8 +462,9 @@ namespace YAML
   StringCharSource tagBuffer(tag.c_str(), tag.size());
   while (tagBuffer) {
     int n = Exp::Tag().Match(tagBuffer);
-				if(n <= 0)
+    if (n <= 0) {
       return false;
+    }
 
     while (--n >= 0) {
       out << tagBuffer[0];
@@ -414,11 +474,10 @@ namespace YAML
   return true;
 }
 
-		bool WriteBinary(ostream_wrapper& out, const Binary& binary)
+bool WriteBinary(ostream_wrapper& out, const Binary& binary) {
-		{
+  WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()),
-            WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()), false);
+                          false);
   return true;
 }
-	}
+}  // namespace Utils
-}
+}  // namespace YAML
-

src/emitterutils.h

@@ -1,34 +1,48 @@
 #ifndef EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EMITTERUTILS_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 "emitterstate.h"
-#include "yaml-cpp/ostream_wrapper.h"
 #include <string>
 
-namespace YAML
+#include "emitterstate.h"
-{
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/ostream_wrapper.h"
+
+namespace YAML {
+class ostream_wrapper;
+}  // namespace YAML
+
+namespace YAML {
 class Binary;
 
-    struct StringFormat { enum value { Plain, SingleQuoted, DoubleQuoted, Literal }; };
+struct StringFormat {
+  enum value { Plain, SingleQuoted, DoubleQuoted, Literal };
+};
 
-	namespace Utils
+namespace Utils {
-	{
+StringFormat::value ComputeStringFormat(const std::string& str,
-        StringFormat::value ComputeStringFormat(const std::string& str, EMITTER_MANIP strFormat, FlowType::value flowType, bool escapeNonAscii);
+                                        EMITTER_MANIP strFormat,
+                                        FlowType::value flowType,
+                                        bool escapeNonAscii);
 
 bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str);
-		bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, bool escapeNonAscii);
+bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
-		bool WriteLiteralString(ostream_wrapper& out, const std::string& str, int indent);
+                             bool escapeNonAscii);
+bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
+                        std::size_t indent);
 bool WriteChar(ostream_wrapper& out, char ch);
-		bool WriteComment(ostream_wrapper& out, const std::string& str, int postCommentIndent);
+bool WriteComment(ostream_wrapper& out, const std::string& str,
+                  std::size_t postCommentIndent);
 bool WriteAlias(ostream_wrapper& out, const std::string& str);
 bool WriteAnchor(ostream_wrapper& out, const std::string& str);
 bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim);
-		bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix, const std::string& tag);
+bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix,
+                        const std::string& tag);
 bool WriteBinary(ostream_wrapper& out, const Binary& binary);
 }
 }

src/exceptions.cpp

@@ -0,0 +1,20 @@
+#include "yaml-cpp/exceptions.h"
+#include "yaml-cpp/noexcept.h"
+
+namespace YAML {
+
+// These destructors are defined out-of-line so the vtable is only emitted once.
+Exception::~Exception() YAML_CPP_NOEXCEPT = default;
+ParserException::~ParserException() YAML_CPP_NOEXCEPT = default;
+RepresentationException::~RepresentationException() YAML_CPP_NOEXCEPT = default;
+InvalidScalar::~InvalidScalar() YAML_CPP_NOEXCEPT = default;
+KeyNotFound::~KeyNotFound() YAML_CPP_NOEXCEPT = default;
+InvalidNode::~InvalidNode() YAML_CPP_NOEXCEPT = default;
+BadConversion::~BadConversion() YAML_CPP_NOEXCEPT = default;
+BadDereference::~BadDereference() YAML_CPP_NOEXCEPT = default;
+BadSubscript::~BadSubscript() YAML_CPP_NOEXCEPT = default;
+BadPushback::~BadPushback() YAML_CPP_NOEXCEPT = default;
+BadInsert::~BadInsert() YAML_CPP_NOEXCEPT = default;
+EmitterException::~EmitterException() YAML_CPP_NOEXCEPT = default;
+BadFile::~BadFile() YAML_CPP_NOEXCEPT = default;
+}

src/exp.cpp

@@ -1,16 +1,18 @@
-#include "exp.h"
-#include "yaml-cpp/exceptions.h"
 #include <sstream>
 
-namespace YAML
+#include "exp.h"
-{
+#include "stream.h"
-	namespace Exp
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
-	{
+
-		unsigned ParseHex(const std::string& str, const Mark& mark)
+namespace YAML {
-		{
+struct Mark;
+}  // namespace YAML
+
+namespace YAML {
+namespace Exp {
+unsigned ParseHex(const std::string& str, const Mark& mark) {
   unsigned value = 0;
-			for(std::size_t i=0;i<str.size();i++) {
+  for (char ch : str) {
-				char ch = str[i];
     int digit = 0;
     if ('a' <= ch && ch <= 'f')
       digit = ch - 'a' + 10;
@@ -27,16 +29,13 @@ namespace YAML
   return value;
 }
 
-		std::string Str(unsigned ch)
+std::string Str(unsigned ch) { return std::string(1, static_cast<char>(ch)); }
-		{
-			return std::string(1, static_cast<char>(ch));
-		}
 
 // Escape
-		// . Translates the next 'codeLength' characters into a hex number and returns the result.
+// . Translates the next 'codeLength' characters into a hex number and returns
+// the result.
 // . Throws if it's not actually hex.
-		std::string Escape(Stream& in, int codeLength)
+std::string Escape(Stream& in, int codeLength) {
-		{
   // grab string
   std::string str;
   for (int i = 0; i < codeLength; i++)
@@ -58,18 +57,19 @@ namespace YAML
   else if (value <= 0x7FF)
     return Str(0xC0 + (value >> 6)) + Str(0x80 + (value & 0x3F));
   else if (value <= 0xFFFF)
-				return Str(0xE0 + (value >> 12)) + Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F));
+    return Str(0xE0 + (value >> 12)) + Str(0x80 + ((value >> 6) & 0x3F)) +
+           Str(0x80 + (value & 0x3F));
   else
     return Str(0xF0 + (value >> 18)) + Str(0x80 + ((value >> 12) & 0x3F)) +
            Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F));
 }
 
 // Escape
-		// . Escapes the sequence starting 'in' (it must begin with a '\' or single quote)
+// . Escapes the sequence starting 'in' (it must begin with a '\' or single
+// quote)
 //   and returns the result.
 // . Throws if it's an unknown escape character.
-		std::string Escape(Stream& in)
+std::string Escape(Stream& in) {
-		{
   // eat slash
   char escape = in.get();
 
@@ -80,34 +80,56 @@ namespace YAML
   if (escape == '\'' && ch == '\'')
     return "\'";
 
-			// now do the slash (we're not gonna check if it's a slash - you better pass one!)
+  // now do the slash (we're not gonna check if it's a slash - you better pass
+  // one!)
   switch (ch) {
-				case '0': return std::string(1, '\x00');
+    case '0':
-				case 'a': return "\x07";
+      return std::string(1, '\x00');
-				case 'b': return "\x08";
+    case 'a':
+      return "\x07";
+    case 'b':
+      return "\x08";
     case 't':
-                case '\t': return "\x09";
+    case '\t':
-				case 'n': return "\x0A";
+      return "\x09";
-				case 'v': return "\x0B";
+    case 'n':
-				case 'f': return "\x0C";
+      return "\x0A";
-				case 'r': return "\x0D";
+    case 'v':
-				case 'e': return "\x1B";
+      return "\x0B";
-				case ' ': return "\x20";
+    case 'f':
-				case '\"': return "\"";
+      return "\x0C";
-				case '\'': return "\'";
+    case 'r':
-				case '\\': return "\\";
+      return "\x0D";
-				case '/': return "/";
+    case 'e':
-				case 'N': return "\x85";
+      return "\x1B";
-				case '_': return "\xA0";
+    case ' ':
-				case 'L': return "\xE2\x80\xA8";  // LS (#x2028)
+      return "\x20";
-				case 'P': return "\xE2\x80\xA9";  // PS (#x2029)
+    case '\"':
-				case 'x': return Escape(in, 2);
+      return "\"";
-				case 'u': return Escape(in, 4);
+    case '\'':
-				case 'U': return Escape(in, 8);
+      return "\'";
+    case '\\':
+      return "\\";
+    case '/':
+      return "/";
+    case 'N':
+      return "\x85";
+    case '_':
+      return "\xA0";
+    case 'L':
+      return "\xE2\x80\xA8";  // LS (#x2028)
+    case 'P':
+      return "\xE2\x80\xA9";  // PS (#x2029)
+    case 'x':
+      return Escape(in, 2);
+    case 'u':
+      return Escape(in, 4);
+    case 'U':
+      return Escape(in, 8);
   }
 
   std::stringstream msg;
   throw ParserException(in.mark(), std::string(ErrorMsg::INVALID_ESCAPE) + ch);
 }
-	}
+}  // namespace Exp
-}
+}  // namespace YAML

src/exp.h

@@ -1,24 +1,29 @@
 #ifndef EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define EXP_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 "regex.h"
-#include <string>
 #include <ios>
+#include <string>
+
+#include "regex_yaml.h"
 #include "stream.h"
 
-namespace YAML
+namespace YAML {
-{
 ////////////////////////////////////////////////////////////////////////////////
-	// Here we store a bunch of expressions for matching different parts of the file.
+// Here we store a bunch of expressions for matching different parts of the
+// file.
 
-	namespace Exp
+namespace Exp {
-	{
 // misc
+inline const RegEx& Empty() {
+  static const RegEx e;
+  return e;
+}
 inline const RegEx& Space() {
   static const RegEx e = RegEx(' ');
   return e;
@@ -28,15 +33,15 @@ namespace YAML
   return e;
 }
 inline const RegEx& Blank() {
-			static const RegEx e = Space() || Tab();
+  static const RegEx e = Space() | Tab();
   return e;
 }
 inline const RegEx& Break() {
-			static const RegEx e = RegEx('\n') || RegEx("\r\n");
+  static const RegEx e = RegEx('\n') | RegEx("\r\n");
   return e;
 }
 inline const RegEx& BlankOrBreak() {
-			static const RegEx e = Blank() || Break();
+  static const RegEx e = Blank() | Break();
   return e;
 }
 inline const RegEx& Digit() {
@@ -44,27 +49,29 @@ namespace YAML
   return e;
 }
 inline const RegEx& Alpha() {
-			static const RegEx e = RegEx('a', 'z') || RegEx('A', 'Z');
+  static const RegEx e = RegEx('a', 'z') | RegEx('A', 'Z');
   return e;
 }
 inline const RegEx& AlphaNumeric() {
-			static const RegEx e = Alpha() || Digit();
+  static const RegEx e = Alpha() | Digit();
   return e;
 }
 inline const RegEx& Word() {
-			static const RegEx e = AlphaNumeric() || RegEx('-');
+  static const RegEx e = AlphaNumeric() | RegEx('-');
   return e;
 }
 inline const RegEx& Hex() {
-			static const RegEx e = Digit() || RegEx('A', 'F') || RegEx('a', 'f');
+  static const RegEx e = Digit() | RegEx('A', 'F') | RegEx('a', 'f');
   return e;
 }
-		// Valid Unicode code points that are not part of c-printable (YAML 1.2, sec. 5.1)
+// Valid Unicode code points that are not part of c-printable (YAML 1.2, sec.
+// 5.1)
 inline const RegEx& NotPrintable() {
-			static const RegEx e = RegEx(0) || 
+  static const RegEx e =
-				RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) || 
+      RegEx(0) |
-				RegEx(0x0E, 0x1F) ||
+      RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) |
-				(RegEx('\xC2') + (RegEx('\x80', '\x84') || RegEx('\x86', '\x9F')));
+      RegEx(0x0E, 0x1F) |
+      (RegEx('\xC2') + (RegEx('\x80', '\x84') | RegEx('\x86', '\x9F')));
   return e;
 }
 inline const RegEx& Utf8_ByteOrderMark() {
@@ -75,19 +82,19 @@ namespace YAML
 // actual tags
 
 inline const RegEx& DocStart() {
-			static const RegEx e = RegEx("---") + (BlankOrBreak() || RegEx());
+  static const RegEx e = RegEx("---") + (BlankOrBreak() | RegEx());
   return e;
 }
 inline const RegEx& DocEnd() {
-			static const RegEx e = RegEx("...") + (BlankOrBreak() || RegEx());
+  static const RegEx e = RegEx("...") + (BlankOrBreak() | RegEx());
   return e;
 }
 inline const RegEx& DocIndicator() {
-			static const RegEx e = DocStart() || DocEnd();
+  static const RegEx e = DocStart() | DocEnd();
   return e;
 }
 inline const RegEx& BlockEntry() {
-			static const RegEx e = RegEx('-') + (BlankOrBreak() || RegEx());
+  static const RegEx e = RegEx('-') + (BlankOrBreak() | RegEx());
   return e;
 }
 inline const RegEx& Key() {
@@ -99,11 +106,11 @@ namespace YAML
   return e;
 }
 inline const RegEx& Value() {
-			static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx());
+  static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx());
   return e;
 }
 inline const RegEx& ValueInFlow() {
-			static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx(",}", REGEX_OR));
+  static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx(",}", REGEX_OR));
   return e;
 }
 inline const RegEx& ValueInJSONFlow() {
@@ -115,19 +122,21 @@ namespace YAML
   return e;
 }
 inline const RegEx& Anchor() {
-			static const RegEx e = !(RegEx("[]{},", REGEX_OR) || BlankOrBreak());
+  static const RegEx e = !(RegEx("[]{},", REGEX_OR) | BlankOrBreak());
   return e;
 }
 inline const RegEx& AnchorEnd() {
-			static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) || BlankOrBreak();
+  static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) | BlankOrBreak();
   return e;
 }
 inline const RegEx& URI() {
-			static const RegEx e = Word() || RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) || (RegEx('%') + Hex() + Hex());
+  static const RegEx e = Word() | RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) |
+                         (RegEx('%') + Hex() + Hex());
   return e;
 }
 inline const RegEx& Tag() {
-			static const RegEx e = Word() || RegEx("#;/?:@&=+$_.~*'", REGEX_OR) || (RegEx('%') + Hex() + Hex());
+  static const RegEx e = Word() | RegEx("#;/?:@&=+$_.~*'()", REGEX_OR) |
+                         (RegEx('%') + Hex() + Hex());
   return e;
 }
 
@@ -135,24 +144,40 @@ namespace YAML
 // . Cannot start with a blank.
 // . Can never start with any of , [ ] { } # & * ! | > \' \" % @ `
 // . In the block context - ? : must be not be followed with a space.
-		// . In the flow context ? is illegal and : and - must not be followed with a space.
+// . In the flow context ? is illegal and : and - must not be followed with a
+// space.
 inline const RegEx& PlainScalar() {
-			static const RegEx e = !(BlankOrBreak() || RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) || (RegEx("-?:", REGEX_OR) + (BlankOrBreak() || RegEx())));
+  static const RegEx e =
+      !(BlankOrBreak() | RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) |
+        (RegEx("-?:", REGEX_OR) + (BlankOrBreak() | RegEx())));
   return e;
 }
 inline const RegEx& PlainScalarInFlow() {
-			static const RegEx e = !(BlankOrBreak() || RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) || (RegEx("-:", REGEX_OR) + Blank()));
+  static const RegEx e =
+      !(BlankOrBreak() | RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) |
+        (RegEx("-:", REGEX_OR) + Blank()));
   return e;
 }
 inline const RegEx& EndScalar() {
-			static const RegEx e = RegEx(':') + (BlankOrBreak() || RegEx());
+  static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx());
   return e;
 }
 inline const RegEx& EndScalarInFlow() {
-			static const RegEx e = (RegEx(':') + (BlankOrBreak() || RegEx() || RegEx(",]}", REGEX_OR))) || RegEx(",?[]{}", REGEX_OR);
+  static const RegEx e =
+      (RegEx(':') + (BlankOrBreak() | RegEx() | RegEx(",]}", REGEX_OR))) |
+      RegEx(",?[]{}", REGEX_OR);
   return e;
 }
 
+inline const RegEx& ScanScalarEndInFlow() {
+  static const RegEx e = (EndScalarInFlow() | (BlankOrBreak() + Comment()));
+  return e;
+}
+
+inline const RegEx& ScanScalarEnd() {
+  static const RegEx e = EndScalar() | (BlankOrBreak() + Comment());
+  return e;
+}
 inline const RegEx& EscSingleQuote() {
   static const RegEx e = RegEx("\'\'");
   return e;
@@ -167,16 +192,17 @@ namespace YAML
   return e;
 }
 inline const RegEx& Chomp() {
-			static const RegEx e = (ChompIndicator() + Digit()) || (Digit() + ChompIndicator()) || ChompIndicator() || Digit();
+  static const RegEx e = (ChompIndicator() + Digit()) |
+                         (Digit() + ChompIndicator()) | ChompIndicator() |
+                         Digit();
   return e;
 }
 
 // and some functions
 std::string Escape(Stream& in);
-	}
+}  // namespace Exp
 
-	namespace Keys
+namespace Keys {
-	{
 const char Directive = '%';
 const char FlowSeqStart = '[';
 const char FlowSeqEnd = ']';
@@ -190,7 +216,7 @@ namespace YAML
 const char FoldedScalar = '>';
 const char VerbatimTagStart = '<';
 const char VerbatimTagEnd = '>';
-	}
+}  // namespace Keys
-}
+}  // namespace YAML
 
 #endif  // EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/indentation.h

@@ -1,38 +1,41 @@
 #ifndef INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define INDENTATION_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 <iostream>
+#include <cstddef>
 
 #include "yaml-cpp/ostream_wrapper.h"
-#include <iostream>
 
-namespace YAML
+namespace YAML {
-{
 struct Indentation {
-		Indentation(unsigned n_): n(n_) {}
+  Indentation(std::size_t n_) : n(n_) {}
-		unsigned n;
+  std::size_t n;
 };
 
-	inline ostream_wrapper& operator << (ostream_wrapper& out, const Indentation& indent) {
+inline ostream_wrapper& operator<<(ostream_wrapper& out,
-		for(unsigned i=0;i<indent.n;i++)
+                                   const Indentation& indent) {
+  for (std::size_t i = 0; i < indent.n; i++)
     out << ' ';
   return out;
 }
 
 struct IndentTo {
-		IndentTo(unsigned n_): n(n_) {}
+  IndentTo(std::size_t n_) : n(n_) {}
-		unsigned n;
+  std::size_t n;
 };
 
-	inline ostream_wrapper& operator << (ostream_wrapper& out, const IndentTo& indent) {
+inline ostream_wrapper& operator<<(ostream_wrapper& out,
+                                   const IndentTo& indent) {
   while (out.col() < indent.n)
     out << ' ';
   return out;
 }
 }
 
-
 #endif  // INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/memory.cpp

@@ -1,12 +1,11 @@
 #include "yaml-cpp/node/detail/memory.h"
-#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/node/detail/node.h"  // IWYU pragma: keep
+#include "yaml-cpp/node/ptr.h"
 
-namespace YAML
+namespace YAML {
-{
+namespace detail {
-	namespace detail
+
-	{
+void memory_holder::merge(memory_holder& rhs) {
-		void memory_holder::merge(memory_holder& rhs)
-		{
   if (m_pMemory == rhs.m_pMemory)
     return;
 
@@ -14,15 +13,13 @@ namespace YAML
   rhs.m_pMemory = m_pMemory;
 }
 
-		node& memory::create_node()
+node& memory::create_node() {
-		{
   shared_node pNode(new node);
   m_nodes.insert(pNode);
   return *pNode;
 }
 
-		void memory::merge(const memory& rhs)
+void memory::merge(const memory& rhs) {
-		{
   m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end());
 }
 }

src/node.cpp

@@ -2,10 +2,8 @@
 #include "nodebuilder.h"
 #include "nodeevents.h"
 
-namespace YAML
+namespace YAML {
-{
+Node Clone(const Node& node) {
-    Node Clone(const Node& node)
-    {
   NodeEvents events(node);
   NodeBuilder builder;
   events.Emit(builder);

src/node_data.cpp

@@ -1,35 +1,51 @@
-#include "yaml-cpp/node/detail/node_data.h"
+#include <cassert>
-#include "yaml-cpp/node/detail/memory.h"
+#include <iterator>
-#include "yaml-cpp/node/detail/node.h"
-#include "yaml-cpp/exceptions.h"
 #include <sstream>
 
-namespace YAML
+#include "yaml-cpp/exceptions.h"
-{
+#include "yaml-cpp/node/detail/memory.h"
-	namespace detail
+#include "yaml-cpp/node/detail/node.h"  // IWYU pragma: keep
-	{
+#include "yaml-cpp/node/detail/node_data.h"
-		std::string node_data::empty_scalar;
+#include "yaml-cpp/node/detail/node_iterator.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/type.h"
 
-		node_data::node_data(): m_isDefined(false), m_type(NodeType::Null), m_seqSize(0)
+namespace YAML {
-		{
+namespace detail {
+std::atomic<size_t> node::m_amount{0};
+
+const std::string& node_data::empty_scalar() {
+  static const std::string svalue;
+  return svalue;
 }
 
-		void node_data::mark_defined()
+node_data::node_data()
-		{
+    : m_isDefined(false),
+      m_mark(Mark::null_mark()),
+      m_type(NodeType::Null),
+      m_tag{},
+      m_style(EmitterStyle::Default),
+      m_scalar{},
+      m_sequence{},
+      m_seqSize(0),
+      m_map{},
+      m_undefinedPairs{} {}
+
+void node_data::mark_defined() {
   if (m_type == NodeType::Undefined)
     m_type = NodeType::Null;
   m_isDefined = true;
 }
 
-		void node_data::set_type(NodeType::value type)
+void node_data::set_mark(const Mark& mark) { m_mark = mark; }
-		{
+
+void node_data::set_type(NodeType::value type) {
   if (type == NodeType::Undefined) {
     m_type = type;
     m_isDefined = false;
     return;
   }
 
-
   m_isDefined = true;
   if (type == m_type)
     return;
@@ -54,107 +70,112 @@ namespace YAML
   }
 }
 
-		void node_data::set_tag(const std::string& tag)
+void node_data::set_tag(const std::string& tag) { m_tag = tag; }
-		{
-			m_tag = tag;
-		}
 
-		void node_data::set_null()
+void node_data::set_style(EmitterStyle::value style) { m_style = style; }
-		{
+
+void node_data::set_null() {
   m_isDefined = true;
   m_type = NodeType::Null;
 }
 
-		void node_data::set_scalar(const std::string& scalar)
+void node_data::set_scalar(const std::string& scalar) {
-		{
   m_isDefined = true;
   m_type = NodeType::Scalar;
   m_scalar = scalar;
 }
 
 // size/iterator
-		std::size_t node_data::size() const
+std::size_t node_data::size() const {
-		{
   if (!m_isDefined)
     return 0;
 
   switch (m_type) {
-				case NodeType::Sequence: compute_seq_size(); return m_seqSize;
+    case NodeType::Sequence:
-				case NodeType::Map: compute_map_size(); return m_map.size() - m_undefinedPairs.size();
+      compute_seq_size();
+      return m_seqSize;
+    case NodeType::Map:
+      compute_map_size();
+      return m_map.size() - m_undefinedPairs.size();
     default:
       return 0;
   }
   return 0;
 }
 
-		void node_data::compute_seq_size() const
+void node_data::compute_seq_size() const {
-		{
   while (m_seqSize < m_sequence.size() && m_sequence[m_seqSize]->is_defined())
     m_seqSize++;
 }
 
-		void node_data::compute_map_size() const
+void node_data::compute_map_size() const {
-		{
   kv_pairs::iterator it = m_undefinedPairs.begin();
   while (it != m_undefinedPairs.end()) {
-				kv_pairs::iterator jt = boost::next(it);
+    kv_pairs::iterator jt = std::next(it);
     if (it->first->is_defined() && it->second->is_defined())
       m_undefinedPairs.erase(it);
     it = jt;
   }
 }
 
-		const_node_iterator node_data::begin() const
+const_node_iterator node_data::begin() const {
-		{
   if (!m_isDefined)
     return const_node_iterator();
 
   switch (m_type) {
-				case NodeType::Sequence: return const_node_iterator(m_sequence.begin());
+    case NodeType::Sequence:
-				case NodeType::Map: return const_node_iterator(m_map.begin(), m_map.end());
+      return const_node_iterator(m_sequence.begin());
-				default: return const_node_iterator();
+    case NodeType::Map:
+      return const_node_iterator(m_map.begin(), m_map.end());
+    default:
+      return const_node_iterator();
   }
 }
 
-		node_iterator node_data::begin()
+node_iterator node_data::begin() {
-		{
   if (!m_isDefined)
     return node_iterator();
 
   switch (m_type) {
-				case NodeType::Sequence: return node_iterator(m_sequence.begin());
+    case NodeType::Sequence:
-				case NodeType::Map: return node_iterator(m_map.begin(), m_map.end());
+      return node_iterator(m_sequence.begin());
-				default: return node_iterator();
+    case NodeType::Map:
+      return node_iterator(m_map.begin(), m_map.end());
+    default:
+      return node_iterator();
   }
 }
 
-		const_node_iterator node_data::end() const
+const_node_iterator node_data::end() const {
-		{
   if (!m_isDefined)
     return const_node_iterator();
 
   switch (m_type) {
-				case NodeType::Sequence: return const_node_iterator(m_sequence.end());
+    case NodeType::Sequence:
-				case NodeType::Map: return const_node_iterator(m_map.end(), m_map.end());
+      return const_node_iterator(m_sequence.end());
-				default: return const_node_iterator();
+    case NodeType::Map:
+      return const_node_iterator(m_map.end(), m_map.end());
+    default:
+      return const_node_iterator();
   }
 }
 
-		node_iterator node_data::end()
+node_iterator node_data::end() {
-		{
   if (!m_isDefined)
     return node_iterator();
 
   switch (m_type) {
-				case NodeType::Sequence: return node_iterator(m_sequence.end());
+    case NodeType::Sequence:
-				case NodeType::Map: return node_iterator(m_map.end(), m_map.end());
+      return node_iterator(m_sequence.end());
-				default: return node_iterator();
+    case NodeType::Map:
+      return node_iterator(m_map.end(), m_map.end());
+    default:
+      return node_iterator();
   }
 }
 
 // sequence
-		void node_data::push_back(node& node, shared_memory_holder /* pMemory */)
+void node_data::push_back(node& node, shared_memory_holder /* pMemory */) {
-		{
   if (m_type == NodeType::Undefined || m_type == NodeType::Null) {
     m_type = NodeType::Sequence;
     reset_sequence();
@@ -166,8 +187,7 @@ namespace YAML
   m_sequence.push_back(&node);
 }
 
-		void node_data::insert(node& key, node& value, shared_memory_holder pMemory)
+void node_data::insert(node& key, node& value, shared_memory_holder pMemory) {
-		{
   switch (m_type) {
     case NodeType::Map:
       break;
@@ -177,28 +197,27 @@ namespace YAML
       convert_to_map(pMemory);
       break;
     case NodeType::Scalar:
-                    throw BadSubscript();
+      throw BadSubscript(m_mark, key);
   }
 
   insert_map_pair(key, value);
 }
 
 // indexing
-		node& node_data::get(node& key, shared_memory_holder pMemory) const
+node* node_data::get(node& key, shared_memory_holder /* pMemory */) const {
-		{
+  if (m_type != NodeType::Map) {
-			if(m_type != NodeType::Map)
+    return nullptr;
-				return pMemory->create_node();
+  }
 
   for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
     if (it->first->is(key))
-					return *it->second;
+      return it->second;
   }
 
-			return pMemory->create_node();
+  return nullptr;
 }
 
-		node& node_data::get(node& key, shared_memory_holder pMemory)
+node& node_data::get(node& key, shared_memory_holder pMemory) {
-		{
   switch (m_type) {
     case NodeType::Map:
       break;
@@ -208,7 +227,7 @@ namespace YAML
       convert_to_map(pMemory);
       break;
     case NodeType::Scalar:
-                    throw BadSubscript();
+      throw BadSubscript(m_mark, key);
   }
 
   for (node_map::const_iterator it = m_map.begin(); it != m_map.end(); ++it) {
@@ -221,11 +240,18 @@ namespace YAML
   return value;
 }
 
-		bool node_data::remove(node& key, shared_memory_holder /* pMemory */)
+bool node_data::remove(node& key, shared_memory_holder /* pMemory */) {
-		{
   if (m_type != NodeType::Map)
     return false;
 
+  for (kv_pairs::iterator it = m_undefinedPairs.begin();
+       it != m_undefinedPairs.end();) {
+    kv_pairs::iterator jt = std::next(it);
+    if (it->first->is(key))
+      m_undefinedPairs.erase(it);
+    it = jt;
+  }
+
   for (node_map::iterator it = m_map.begin(); it != m_map.end(); ++it) {
     if (it->first->is(key)) {
       m_map.erase(it);
@@ -236,27 +262,24 @@ namespace YAML
   return false;
 }
 
-		void node_data::reset_sequence()
+void node_data::reset_sequence() {
-		{
   m_sequence.clear();
   m_seqSize = 0;
 }
 
-		void node_data::reset_map()
+void node_data::reset_map() {
-		{
   m_map.clear();
   m_undefinedPairs.clear();
 }
 
-		void node_data::insert_map_pair(node& key, node& value)
+void node_data::insert_map_pair(node& key, node& value) {
-		{
+  m_map.emplace_back(&key, &value);
-			m_map[&key] = &value;
+
   if (!key.is_defined() || !value.is_defined())
-				m_undefinedPairs.push_back(kv_pair(&key, &value));
+    m_undefinedPairs.emplace_back(&key, &value);
 }
 
-		void node_data::convert_to_map(shared_memory_holder pMemory)
+void node_data::convert_to_map(shared_memory_holder pMemory) {
-		{
   switch (m_type) {
     case NodeType::Undefined:
     case NodeType::Null:
@@ -274,8 +297,7 @@ namespace YAML
   }
 }
 
-		void node_data::convert_sequence_to_map(shared_memory_holder pMemory)
+void node_data::convert_sequence_to_map(shared_memory_holder pMemory) {
-		{
   assert(m_type == NodeType::Sequence);
 
   reset_map();
@@ -291,5 +313,5 @@ namespace YAML
   reset_sequence();
   m_type = NodeType::Map;
 }
-	}
+}  // namespace detail
-}
+}  // namespace YAML

src/nodebuilder.cpp

@@ -1,104 +1,101 @@
-#include "nodebuilder.h"
-#include "yaml-cpp/mark.h"
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/impl.h"
 #include <cassert>
 
-namespace YAML
+#include "nodebuilder.h"
-{
+#include "yaml-cpp/node/detail/node.h"
-	NodeBuilder::NodeBuilder(): m_pMemory(new detail::memory_holder), m_pRoot(0), m_mapDepth(0)
+#include "yaml-cpp/node/impl.h"
-	{
+#include "yaml-cpp/node/node.h"
-		m_anchors.push_back(0); // since the anchors start at 1
+#include "yaml-cpp/node/type.h"
+
+namespace YAML {
+struct Mark;
+
+NodeBuilder::NodeBuilder()
+    : m_pMemory(new detail::memory_holder),
+      m_pRoot(nullptr),
+      m_stack{},
+      m_anchors{},
+      m_keys{},
+      m_mapDepth(0) {
+  m_anchors.push_back(nullptr);  // since the anchors start at 1
 }
 
-	NodeBuilder::~NodeBuilder()
+NodeBuilder::~NodeBuilder() = default;
-	{
-	}
 
-	Node NodeBuilder::Root()
+Node NodeBuilder::Root() {
-	{
   if (!m_pRoot)
     return Node();
 
   return Node(*m_pRoot, m_pMemory);
 }
 
-	void NodeBuilder::OnDocumentStart(const Mark&)
+void NodeBuilder::OnDocumentStart(const Mark&) {}
-	{
-	}
 
-	void NodeBuilder::OnDocumentEnd()
+void NodeBuilder::OnDocumentEnd() {}
-	{
-	}
 
-	void NodeBuilder::OnNull(const Mark& /* mark */, anchor_t anchor)
+void NodeBuilder::OnNull(const Mark& mark, anchor_t anchor) {
-	{
+  detail::node& node = Push(mark, anchor);
-		detail::node& node = Push(anchor);
   node.set_null();
   Pop();
 }
 
-	void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor)
+void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor) {
-	{
   detail::node& node = *m_anchors[anchor];
   Push(node);
   Pop();
 }
 
-	void NodeBuilder::OnScalar(const Mark& /* mark */, const std::string& tag, anchor_t anchor, const std::string& value)
+void NodeBuilder::OnScalar(const Mark& mark, const std::string& tag,
-	{
+                           anchor_t anchor, const std::string& value) {
-		detail::node& node = Push(anchor);
+  detail::node& node = Push(mark, anchor);
   node.set_scalar(value);
   node.set_tag(tag);
   Pop();
 }
 
-	void NodeBuilder::OnSequenceStart(const Mark& /* mark */, const std::string& tag, anchor_t anchor)
+void NodeBuilder::OnSequenceStart(const Mark& mark, const std::string& tag,
-	{
+                                  anchor_t anchor, EmitterStyle::value style) {
-		detail::node& node = Push(anchor);
+  detail::node& node = Push(mark, anchor);
   node.set_tag(tag);
   node.set_type(NodeType::Sequence);
+  node.set_style(style);
 }
 
-	void NodeBuilder::OnSequenceEnd()
+void NodeBuilder::OnSequenceEnd() { Pop(); }
-	{
-		Pop();
-	}
 
-	void NodeBuilder::OnMapStart(const Mark& /* mark */, const std::string& tag, anchor_t anchor)
+void NodeBuilder::OnMapStart(const Mark& mark, const std::string& tag,
-	{
+                             anchor_t anchor, EmitterStyle::value style) {
-		detail::node& node = Push(anchor);
+  detail::node& node = Push(mark, anchor);
   node.set_type(NodeType::Map);
   node.set_tag(tag);
+  node.set_style(style);
   m_mapDepth++;
 }
 
-	void NodeBuilder::OnMapEnd()
+void NodeBuilder::OnMapEnd() {
-	{
   assert(m_mapDepth > 0);
   m_mapDepth--;
   Pop();
 }
 
-	detail::node& NodeBuilder::Push(anchor_t anchor)
+detail::node& NodeBuilder::Push(const Mark& mark, anchor_t anchor) {
-	{
   detail::node& node = m_pMemory->create_node();
+  node.set_mark(mark);
   RegisterAnchor(anchor, node);
   Push(node);
   return node;
 }
 
-	void NodeBuilder::Push(detail::node& node)
+void NodeBuilder::Push(detail::node& node) {
-	{
+  const bool needsKey =
-		const bool needsKey = (!m_stack.empty() && m_stack.back()->type() == NodeType::Map && m_keys.size() < m_mapDepth);
+      (!m_stack.empty() && m_stack.back()->type() == NodeType::Map &&
+       m_keys.size() < m_mapDepth);
 
   m_stack.push_back(&node);
   if (needsKey)
     m_keys.push_back(PushedKey(&node, false));
 }
 
-	void NodeBuilder::Pop()
+void NodeBuilder::Pop() {
-	{
   assert(!m_stack.empty());
   if (m_stack.size() == 1) {
     m_pRoot = m_stack[0];
@@ -128,11 +125,10 @@ namespace YAML
   }
 }
 
-	void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node)
+void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) {
-	{
   if (anchor) {
     assert(anchor == m_anchors.size());
     m_anchors.push_back(&node);
   }
 }
-}
+}  // namespace YAML

src/nodebuilder.h

@@ -1,41 +1,58 @@
 #ifndef NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NODE_NODEBUILDER_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 "yaml-cpp/node/ptr.h"
 #include <vector>
 
-namespace YAML
+#include "yaml-cpp/anchor.h"
-{
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/node/ptr.h"
+
+namespace YAML {
+namespace detail {
+class node;
+}  // namespace detail
+struct Mark;
+}  // namespace YAML
+
+namespace YAML {
 class Node;
 
-	class NodeBuilder: public EventHandler
+class NodeBuilder : public EventHandler {
-	{
  public:
   NodeBuilder();
-		virtual ~NodeBuilder();
+  NodeBuilder(const NodeBuilder&) = delete;
+  NodeBuilder(NodeBuilder&&) = delete;
+  NodeBuilder& operator=(const NodeBuilder&) = delete;
+  NodeBuilder& operator=(NodeBuilder&&) = delete;
+  ~NodeBuilder() override;
 
   Node Root();
 
-		virtual void OnDocumentStart(const Mark& mark);
+  void OnDocumentStart(const Mark& mark) override;
-		virtual void OnDocumentEnd();
+  void OnDocumentEnd() override;
 
-		virtual void OnNull(const Mark& mark, anchor_t anchor);
+  void OnNull(const Mark& mark, anchor_t anchor) override;
-		virtual void OnAlias(const Mark& mark, anchor_t anchor);
+  void OnAlias(const Mark& mark, anchor_t anchor) override;
-		virtual void OnScalar(const Mark& mark, const std::string& tag, anchor_t anchor, const std::string& value);
+  void OnScalar(const Mark& mark, const std::string& tag,
+                        anchor_t anchor, const std::string& value) override;
 
-		virtual void OnSequenceStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+  void OnSequenceStart(const Mark& mark, const std::string& tag,
-		virtual void OnSequenceEnd();
+                               anchor_t anchor, EmitterStyle::value style) override;
+  void OnSequenceEnd() override;
 
-		virtual void OnMapStart(const Mark& mark, const std::string& tag, anchor_t anchor);
+  void OnMapStart(const Mark& mark, const std::string& tag,
-		virtual void OnMapEnd();
+                          anchor_t anchor, EmitterStyle::value style) override;
+  void OnMapEnd() override;
 
  private:
-		detail::node& Push(anchor_t anchor);
+  detail::node& Push(const Mark& mark, anchor_t anchor);
   void Push(detail::node& node);
   void Pop();
   void RegisterAnchor(anchor_t anchor, detail::node& node);
@@ -44,15 +61,14 @@ namespace YAML
   detail::shared_memory_holder m_pMemory;
   detail::node* m_pRoot;
 
-		typedef std::vector<detail::node *> Nodes;
+  using Nodes = std::vector<detail::node *>;
   Nodes m_stack;
   Nodes m_anchors;
 
-		typedef std::pair<detail::node *, bool> PushedKey;
+  using PushedKey = std::pair<detail::node*, bool>;
   std::vector<PushedKey> m_keys;
   std::size_t m_mapDepth;
 };
-}
+}  // namespace YAML
 
 #endif  // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

src/nodeevents.cpp

@@ -1,31 +1,31 @@
 #include "nodeevents.h"
-#include "yaml-cpp/node/node.h"
-#include "yaml-cpp/node/impl.h"
 #include "yaml-cpp/eventhandler.h"
 #include "yaml-cpp/mark.h"
+#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/node/detail/node_iterator.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/type.h"
 
-namespace YAML
+namespace YAML {
-{
+void NodeEvents::AliasManager::RegisterReference(const detail::node& node) {
-	void NodeEvents::AliasManager::RegisterReference(const detail::node& node)
-	{
   m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor()));
 }
 
-	anchor_t NodeEvents::AliasManager::LookupAnchor(const detail::node& node) const
+anchor_t NodeEvents::AliasManager::LookupAnchor(
-	{
+    const detail::node& node) const {
   AnchorByIdentity::const_iterator it = m_anchorByIdentity.find(node.ref());
   if (it == m_anchorByIdentity.end())
     return 0;
   return it->second;
 }
 
-	NodeEvents::NodeEvents(const Node& node): m_pMemory(node.m_pMemory), m_root(*node.m_pNode)
+NodeEvents::NodeEvents(const Node& node)
-	{
+    : m_pMemory(node.m_pMemory), m_root(node.m_pNode), m_refCount{} {
-		Setup(m_root);
+  if (m_root)
+    Setup(*m_root);
 }
 
-	void NodeEvents::Setup(const detail::node& node)
+void NodeEvents::Setup(const detail::node& node) {
-	{
   int& refCount = m_refCount[node.ref()];
   refCount++;
   if (refCount > 1)
@@ -35,24 +35,25 @@ namespace YAML
     for (detail::const_node_iterator it = node.begin(); it != node.end(); ++it)
       Setup(**it);
   } else if (node.type() == NodeType::Map) {
-			for(detail::const_node_iterator it=node.begin();it!=node.end();++it) {
+    for (detail::const_node_iterator it = node.begin(); it != node.end();
+         ++it) {
       Setup(*it->first);
       Setup(*it->second);
     }
   }
 }
 
-	void NodeEvents::Emit(EventHandler& handler)
+void NodeEvents::Emit(EventHandler& handler) {
-	{
   AliasManager am;
 
   handler.OnDocumentStart(Mark());
-		Emit(m_root, handler, am);
+  if (m_root)
+    Emit(*m_root, handler, am);
   handler.OnDocumentEnd();
 }
 
-	void NodeEvents::Emit(const detail::node& node, EventHandler& handler, AliasManager& am) const
+void NodeEvents::Emit(const detail::node& node, EventHandler& handler,
-	{
+                      AliasManager& am) const {
   anchor_t anchor = NullAnchor;
   if (IsAliased(node)) {
     anchor = am.LookupAnchor(node);
@@ -75,14 +76,16 @@ namespace YAML
       handler.OnScalar(Mark(), node.tag(), anchor, node.scalar());
       break;
     case NodeType::Sequence:
-				handler.OnSequenceStart(Mark(), node.tag(), anchor);
+      handler.OnSequenceStart(Mark(), node.tag(), anchor, node.style());
-				for(detail::const_node_iterator it=node.begin();it!=node.end();++it)
+      for (detail::const_node_iterator it = node.begin(); it != node.end();
+           ++it)
         Emit(**it, handler, am);
       handler.OnSequenceEnd();
       break;
     case NodeType::Map:
-				handler.OnMapStart(Mark(), node.tag(), anchor);
+      handler.OnMapStart(Mark(), node.tag(), anchor, node.style());
-				for(detail::const_node_iterator it=node.begin();it!=node.end();++it) {
+      for (detail::const_node_iterator it = node.begin(); it != node.end();
+           ++it) {
         Emit(*it->first, handler, am);
         Emit(*it->second, handler, am);
       }
@@ -91,9 +94,8 @@ namespace YAML
   }
 }
 
-	bool NodeEvents::IsAliased(const detail::node& node) const
+bool NodeEvents::IsAliased(const detail::node& node) const {
-	{
   RefCount::const_iterator it = m_refCount.find(node.ref());
   return it != m_refCount.end() && it->second > 1;
 }
-}
+}  // namespace YAML

src/nodeevents.h

@@ -1,31 +1,42 @@
 #ifndef NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define NODE_NODEEVENTS_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 "yaml-cpp/node/ptr.h"
 #include <map>
 #include <vector>
 
-namespace YAML
+#include "yaml-cpp/anchor.h"
-{
+#include "yaml-cpp/node/ptr.h"
+
+namespace YAML {
+namespace detail {
+class node;
+}  // namespace detail
+}  // namespace YAML
+
+namespace YAML {
 class EventHandler;
 class Node;
 
-	class NodeEvents
+class NodeEvents {
-	{
  public:
   explicit NodeEvents(const Node& node);
+  NodeEvents(const NodeEvents&) = delete;
+  NodeEvents(NodeEvents&&) = delete;
+  NodeEvents& operator=(const NodeEvents&) = delete;
+  NodeEvents& operator=(NodeEvents&&) = delete;
 
   void Emit(EventHandler& handler);
 
  private:
   class AliasManager {
    public:
-			AliasManager(): m_curAnchor(0) {}
+    AliasManager() : m_anchorByIdentity{}, m_curAnchor(0) {}
 
     void RegisterReference(const detail::node& node);
     anchor_t LookupAnchor(const detail::node& node) const;
@@ -34,24 +45,24 @@ namespace YAML
     anchor_t _CreateNewAnchor() { return ++m_curAnchor; }
 
    private:
-			typedef std::map<const detail::node_ref*, anchor_t> AnchorByIdentity;
+    using AnchorByIdentity = std::map<const detail::node_ref*, anchor_t>;
     AnchorByIdentity m_anchorByIdentity;
 
     anchor_t m_curAnchor;
   };
 
   void Setup(const detail::node& node);
-		void Emit(const detail::node& node, EventHandler& handler, AliasManager& am) const;
+  void Emit(const detail::node& node, EventHandler& handler,
+            AliasManager& am) const;
   bool IsAliased(const detail::node& node) const;
 
  private:
   detail::shared_memory_holder m_pMemory;
-		detail::node& m_root;
+  detail::node* m_root;
 
-		typedef std::map<const detail::node_ref *, int> RefCount;
+  using RefCount = std::map<const detail::node_ref*, int>;
   RefCount m_refCount;
 };
-}
+}  // namespace YAML
 
 #endif  // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

src/null.cpp

@@ -1,6 +1,10 @@
 #include "yaml-cpp/null.h"
 
-namespace YAML
+namespace YAML {
-{
 _Null Null;
+
+bool IsNullString(const std::string& str) {
+  return str.empty() || str == "~" || str == "null" || str == "Null" ||
+         str == "NULL";
+}
 }

src/ostream_wrapper.cpp

@@ -1,49 +1,55 @@
 #include "yaml-cpp/ostream_wrapper.h"
+
+#include <algorithm>
 #include <cstring>
 #include <iostream>
 
-namespace YAML
+namespace YAML {
-{
+ostream_wrapper::ostream_wrapper()
-	ostream_wrapper::ostream_wrapper(): m_pStream(0), m_pos(0), m_row(0), m_col(0), m_comment(false)
+    : m_buffer(1, '\0'),
-	{
+      m_pStream(nullptr),
-	}
+      m_pos(0),
+      m_row(0),
+      m_col(0),
+      m_comment(false) {}
 
-	ostream_wrapper::ostream_wrapper(std::ostream& stream): m_pStream(&stream), m_pos(0), m_row(0), m_col(0), m_comment(false)
+ostream_wrapper::ostream_wrapper(std::ostream& stream)
-	{
+    : m_buffer{},
-	}
+      m_pStream(&stream),
+      m_pos(0),
+      m_row(0),
+      m_col(0),
+      m_comment(false) {}
 
-	ostream_wrapper::~ostream_wrapper()
+ostream_wrapper::~ostream_wrapper() = default;
-	{
-	}
 
-    void ostream_wrapper::write(const std::string& str)
+void ostream_wrapper::write(const std::string& str) {
-    {
   if (m_pStream) {
     m_pStream->write(str.c_str(), str.size());
   } else {
     m_buffer.resize(std::max(m_buffer.size(), m_pos + str.size() + 1));
-            std::copy(str.begin(), str.end(), &m_buffer[m_pos]);
+    std::copy(str.begin(), str.end(), m_buffer.begin() + m_pos);
   }
 
-        for(std::size_t i=0;i<str.size();i++)
+  for (char ch : str) {
-            update_pos(str[i]);
+    update_pos(ch);
+  }
 }
 
-    void ostream_wrapper::write(const char *str, std::size_t size)
+void ostream_wrapper::write(const char* str, std::size_t size) {
-    {
   if (m_pStream) {
     m_pStream->write(str, size);
   } else {
     m_buffer.resize(std::max(m_buffer.size(), m_pos + size + 1));
-            std::copy(str, str + size, &m_buffer[m_pos]);
+    std::copy(str, str + size, m_buffer.begin() + m_pos);
   }
 
-        for(std::size_t i=0;i<size;i++)
+  for (std::size_t i = 0; i < size; i++) {
     update_pos(str[i]);
   }
+}
 
-    void ostream_wrapper::update_pos(char ch)
+void ostream_wrapper::update_pos(char ch) {
-    {
   m_pos++;
   m_col++;
 
@@ -53,4 +59,4 @@ namespace YAML
     m_comment = false;
   }
 }
-}
+}  // namespace YAML

src/parse.cpp

@@ -1,14 +1,14 @@
 #include "yaml-cpp/node/parse.h"
+
+#include <fstream>
+#include <sstream>
+
 #include "yaml-cpp/node/node.h"
 #include "yaml-cpp/node/impl.h"
 #include "yaml-cpp/parser.h"
 #include "nodebuilder.h"
 
-#include <fstream>
+namespace YAML {
-#include <sstream>
-
-namespace YAML
-{
 Node Load(const std::string& input) {
   std::stringstream stream(input);
   return Load(stream);
@@ -22,16 +22,18 @@ namespace YAML
 Node Load(std::istream& input) {
   Parser parser(input);
   NodeBuilder builder;
-		if(!parser.HandleNextDocument(builder))
+  if (!parser.HandleNextDocument(builder)) {
     return Node();
+  }
 
   return builder.Root();
 }
 
 Node LoadFile(const std::string& filename) {
   std::ifstream fin(filename.c_str());
-        if(!fin)
+  if (!fin) {
     throw BadFile();
+  }
   return Load(fin);
 }
 
@@ -51,8 +53,9 @@ namespace YAML
   Parser parser(input);
   while (1) {
     NodeBuilder builder;
-			if(!parser.HandleNextDocument(builder))
+    if (!parser.HandleNextDocument(builder)) {
       break;
+    }
     docs.push_back(builder.Root());
   }
 
@@ -61,8 +64,9 @@ namespace YAML
 
 std::vector<Node> LoadAllFromFile(const std::string& filename) {
   std::ifstream fin(filename.c_str());
-        if(!fin)
+  if (!fin) {
     throw BadFile();
+  }
   return LoadAll(fin);
 }
-}
+}  // namespace YAML

src/parser.cpp

@@ -1,76 +1,59 @@
-#include "yaml-cpp/parser.h"
-#include "yaml-cpp/eventhandler.h"
-#include "yaml-cpp/exceptions.h"
-#include "directives.h"
-#include "scanner.h"
-#include "singledocparser.h"
-#include "tag.h"
-#include "token.h"
-#include <sstream>
 #include <cstdio>
+#include <sstream>
 
-namespace YAML
+#include "directives.h"  // IWYU pragma: keep
-{
+#include "scanner.h"     // IWYU pragma: keep
-	Parser::Parser()
+#include "singledocparser.h"
-	{
+#include "token.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+#include "yaml-cpp/parser.h"
+
+namespace YAML {
+class EventHandler;
+
+Parser::Parser() : m_pScanner{}, m_pDirectives{} {}
+
+Parser::Parser(std::istream& in) : Parser() { Load(in); }
+
+Parser::~Parser() = default;
+
+Parser::operator bool() const {
+  return m_pScanner && !m_pScanner->empty();
 }
 
-	Parser::Parser(std::istream& in)
+void Parser::Load(std::istream& in) {
-	{
-		Load(in);
-	}
-
-	Parser::~Parser()
-	{
-	}
-
-	Parser::operator bool() const
-	{
-		return m_pScanner.get() && !m_pScanner->empty();
-	}
-
-	void Parser::Load(std::istream& in)
-	{
   m_pScanner.reset(new Scanner(in));
   m_pDirectives.reset(new Directives);
 }
 
-	// HandleNextDocument
+bool Parser::HandleNextDocument(EventHandler& eventHandler) {
-	// . Handles the next document
+  if (!m_pScanner)
-	// . Throws a ParserException on error.
-	// . Returns false if there are no more documents
-	bool Parser::HandleNextDocument(EventHandler& eventHandler)
-	{
-		if(!m_pScanner.get())
     return false;
 
   ParseDirectives();
-		if(m_pScanner->empty())
+  if (m_pScanner->empty()) {
     return false;
+  }
 
   SingleDocParser sdp(*m_pScanner, *m_pDirectives);
   sdp.HandleDocument(eventHandler);
   return true;
 }
 
-	// ParseDirectives
+void Parser::ParseDirectives() {
-	// . Reads any directives that are next in the queue.
-	void Parser::ParseDirectives()
-	{
   bool readDirective = false;
 
-		while(1) {
+  while (!m_pScanner->empty()) {
-			if(m_pScanner->empty())
-				break;
-
     Token& token = m_pScanner->peek();
-			if(token.type != Token::DIRECTIVE)
+    if (token.type != Token::DIRECTIVE) {
       break;
+    }
 
     // we keep the directives from the last document if none are specified;
     // but if any directives are specific, then we reset them
-			if(!readDirective)
+    if (!readDirective) {
       m_pDirectives.reset(new Directives);
+    }
 
     readDirective = true;
     HandleDirective(token);
@@ -78,64 +61,61 @@ namespace YAML
   }
 }
 
-	void Parser::HandleDirective(const Token& token)
+void Parser::HandleDirective(const Token& token) {
-	{
+  if (token.value == "YAML") {
-		if(token.value == "YAML")
     HandleYamlDirective(token);
-		else if(token.value == "TAG")
+  } else if (token.value == "TAG") {
     HandleTagDirective(token);
   }
+}
 
-	// HandleYamlDirective
+void Parser::HandleYamlDirective(const Token& token) {
-	// . Should be of the form 'major.minor' (like a version number)
+  if (token.params.size() != 1) {
-	void Parser::HandleYamlDirective(const Token& token)
-	{
-		if(token.params.size() != 1)
     throw ParserException(token.mark, ErrorMsg::YAML_DIRECTIVE_ARGS);
+  }
 
-		if(!m_pDirectives->version.isDefault)
+  if (!m_pDirectives->version.isDefault) {
     throw ParserException(token.mark, ErrorMsg::REPEATED_YAML_DIRECTIVE);
+  }
 
   std::stringstream str(token.params[0]);
   str >> m_pDirectives->version.major;
   str.get();
   str >> m_pDirectives->version.minor;
-		if(!str || str.peek() != EOF)
+  if (!str || str.peek() != EOF) {
-			throw ParserException(token.mark, std::string(ErrorMsg::YAML_VERSION) + token.params[0]);
+    throw ParserException(
+        token.mark, std::string(ErrorMsg::YAML_VERSION) + token.params[0]);
+  }
 
-		if(m_pDirectives->version.major > 1)
+  if (m_pDirectives->version.major > 1) {
     throw ParserException(token.mark, ErrorMsg::YAML_MAJOR_VERSION);
+  }
 
   m_pDirectives->version.isDefault = false;
   // TODO: warning on major == 1, minor > 2?
 }
 
-	// HandleTagDirective
+void Parser::HandleTagDirective(const Token& token) {
-	// . Should be of the form 'handle prefix', where 'handle' is converted to 'prefix' in the file.
-	void Parser::HandleTagDirective(const Token& token)
-	{
   if (token.params.size() != 2)
     throw ParserException(token.mark, ErrorMsg::TAG_DIRECTIVE_ARGS);
 
   const std::string& handle = token.params[0];
   const std::string& prefix = token.params[1];
-		if(m_pDirectives->tags.find(handle) != m_pDirectives->tags.end())
+  if (m_pDirectives->tags.find(handle) != m_pDirectives->tags.end()) {
     throw ParserException(token.mark, ErrorMsg::REPEATED_TAG_DIRECTIVE);
+  }
 
   m_pDirectives->tags[handle] = prefix;
 }
 
-	void Parser::PrintTokens(std::ostream& out)
+void Parser::PrintTokens(std::ostream& out) {
-	{
+  if (!m_pScanner) {
-		if(!m_pScanner.get())
     return;
+  }
 
-		while(1) {
+  while (!m_pScanner->empty()) {
-			if(m_pScanner->empty())
-				break;
-
     out << m_pScanner->peek() << "\n";
     m_pScanner->pop();
   }
 }
-}
+}  // namespace YAML

src/ptr_stack.h

@@ -1,49 +0,0 @@
-#ifndef PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
-#pragma once
-#endif
-
-#include "yaml-cpp/noncopyable.h"
-#include <cstddef>
-#include <cstdlib>
-#include <memory>
-#include <vector>
-
-template <typename T>
-class ptr_stack: private YAML::noncopyable
-{
-public:
-	ptr_stack() {}
-	~ptr_stack() { clear(); }
-	
-	void clear() {
-		for(unsigned i=0;i<m_data.size();i++)
-			delete m_data[i];
-		m_data.clear();
-	}
-	
-	std::size_t size() const { return m_data.size(); }
-	bool empty() const { return m_data.empty(); }
-	
-	void push(std::auto_ptr<T> t) {
-		m_data.push_back(NULL);
-		m_data.back() = t.release();
-	}
-	std::auto_ptr<T> pop() {
-		std::auto_ptr<T> t(m_data.back());
-		m_data.pop_back();
-		return t;
-	}
-	T& top() { return *m_data.back(); }
-	const T& top() const { return *m_data.back(); }
-
-	T& top(std::ptrdiff_t diff) { return **(m_data.end() - 1 + diff); }
-	const T& top(std::ptrdiff_t diff) const { return **(m_data.end() - 1 + diff); }
-
-private:
-	std::vector<T*> m_data;
-};
-
-#endif // PTR_STACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/ptr_vector.h

@@ -1,11 +1,12 @@
 #ifndef PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define PTR_VECTOR_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/noncopyable.h"
 #include <cstddef>
 #include <cstdlib>
 #include <memory>
@@ -13,35 +14,32 @@
 
 namespace YAML {
 
+// TODO: This class is no longer needed
 template <typename T>
-	class ptr_vector: private YAML::noncopyable
+class ptr_vector {
-	{
  public:
-		ptr_vector() {}
+  ptr_vector() : m_data{} {}
-		~ptr_vector() { clear(); }
+  ptr_vector(const ptr_vector&) = delete;
+  ptr_vector(ptr_vector&&) = default;
+  ptr_vector& operator=(const ptr_vector&) = delete;
+  ptr_vector& operator=(ptr_vector&&) = default;
 
-		void clear() {
+  void clear() { m_data.clear(); }
-			for(unsigned i=0;i<m_data.size();i++)
-				delete m_data[i];
-			m_data.clear();
-		}
 
   std::size_t size() const { return m_data.size(); }
   bool empty() const { return m_data.empty(); }
 
-		void push_back(std::auto_ptr<T> t) {
+  void push_back(std::unique_ptr<T>&& t) { m_data.push_back(std::move(t)); }
-			m_data.push_back(NULL);
-			m_data.back() = t.release();
-		}
   T& operator[](std::size_t i) { return *m_data[i]; }
   const T& operator[](std::size_t i) const { return *m_data[i]; }
 
-		T& back() { return *m_data.back(); }
+  T& back() { return *(m_data.back().get()); }
-		const T& back() const { return *m_data.back(); }
+
+  const T& back() const { return *(m_data.back().get()); }
 
  private:
-		std::vector<T*> m_data;
+  std::vector<std::unique_ptr<T>> m_data;
 };
-}
+}  // namespace YAML
 
 #endif  // PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/regex.cpp

@@ -1,60 +0,0 @@
-#include "regex.h"
-
-namespace YAML
-{
-	// constructors
-	RegEx::RegEx(): m_op(REGEX_EMPTY)
-	{
-	}
-	
-	RegEx::RegEx(REGEX_OP op): m_op(op)
-	{
-	}
-	
-	RegEx::RegEx(char ch): m_op(REGEX_MATCH), m_a(ch)
-	{
-	}
-	
-	RegEx::RegEx(char a, char z): m_op(REGEX_RANGE), m_a(a), m_z(z)
-	{
-	}
-	
-	RegEx::RegEx(const std::string& str, REGEX_OP op): m_op(op)
-	{
-		for(std::size_t i=0;i<str.size();i++)
-			m_params.push_back(RegEx(str[i]));
-	}
-	
-	// combination constructors
-	RegEx operator ! (const RegEx& ex)
-	{
-		RegEx ret(REGEX_NOT);
-		ret.m_params.push_back(ex);
-		return ret;
-	}
-	
-	RegEx operator || (const RegEx& ex1, const RegEx& ex2)
-	{
-		RegEx ret(REGEX_OR);
-		ret.m_params.push_back(ex1);
-		ret.m_params.push_back(ex2);
-		return ret;
-	}
-	
-	RegEx operator && (const RegEx& ex1, const RegEx& ex2)
-	{
-		RegEx ret(REGEX_AND);
-		ret.m_params.push_back(ex1);
-		ret.m_params.push_back(ex2);
-		return ret;
-	}
-	
-	RegEx operator + (const RegEx& ex1, const RegEx& ex2)
-	{
-		RegEx ret(REGEX_SEQ);
-		ret.m_params.push_back(ex1);
-		ret.m_params.push_back(ex2);
-		return ret;
-	}	
-}
-

src/regex.h

@@ -1,67 +0,0 @@
-#ifndef REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-#define REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-
-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
-#pragma once
-#endif
-
-
-#include <vector>
-#include <string>
-
-namespace YAML
-{
-	class Stream;
-
-	enum REGEX_OP { REGEX_EMPTY, REGEX_MATCH, REGEX_RANGE, REGEX_OR, REGEX_AND, REGEX_NOT, REGEX_SEQ };
-
-	// simplified regular expressions
-	// . Only straightforward matches (no repeated characters)
-	// . Only matches from start of string
-	class RegEx
-	{
-	public:
-		RegEx();
-		RegEx(char ch);
-		RegEx(char a, char z);
-		RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
-		~RegEx() {}
-
-		friend RegEx operator ! (const RegEx& ex);
-		friend RegEx operator || (const RegEx& ex1, const RegEx& ex2);
-		friend RegEx operator && (const RegEx& ex1, const RegEx& ex2);
-		friend RegEx operator + (const RegEx& ex1, const RegEx& ex2);
-		
-		bool Matches(char ch) const;
-		bool Matches(const std::string& str) const;
-		bool Matches(const Stream& in) const;
-		template <typename Source> bool Matches(const Source& source) const;
-
-		int Match(const std::string& str) const;
-		int Match(const Stream& in) const;
-		template <typename Source> int Match(const Source& source) const;
-
-	private:
-		RegEx(REGEX_OP op);
-		
-		template <typename Source> bool IsValidSource(const Source& source) const;
-		template <typename Source> int MatchUnchecked(const Source& source) const;
-
-		template <typename Source> int MatchOpEmpty(const Source& source) const;
-		template <typename Source> int MatchOpMatch(const Source& source) const;
-		template <typename Source> int MatchOpRange(const Source& source) const;
-		template <typename Source> int MatchOpOr(const Source& source) const;
-		template <typename Source> int MatchOpAnd(const Source& source) const;
-		template <typename Source> int MatchOpNot(const Source& source) const;
-		template <typename Source> int MatchOpSeq(const Source& source) const;
-
-	private:
-		REGEX_OP m_op;
-		char m_a, m_z;
-		std::vector <RegEx> m_params;
-	};
-}
-
-#include "regeximpl.h"
-
-#endif // REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/regex_yaml.cpp

@@ -0,0 +1,43 @@
+#include "regex_yaml.h"
+
+namespace YAML {
+// constructors
+
+RegEx::RegEx(REGEX_OP op) : m_op(op), m_a(0), m_z(0), m_params{} {}
+RegEx::RegEx() : RegEx(REGEX_EMPTY) {}
+
+RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch), m_z(0), m_params{} {}
+
+RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z), m_params{} {}
+
+RegEx::RegEx(const std::string& str, REGEX_OP op)
+    : m_op(op), m_a(0), m_z(0), m_params(str.begin(), str.end()) {}
+
+// combination constructors
+RegEx operator!(const RegEx& ex) {
+  RegEx ret(REGEX_NOT);
+  ret.m_params.push_back(ex);
+  return ret;
+}
+
+RegEx operator|(const RegEx& ex1, const RegEx& ex2) {
+  RegEx ret(REGEX_OR);
+  ret.m_params.push_back(ex1);
+  ret.m_params.push_back(ex2);
+  return ret;
+}
+
+RegEx operator&(const RegEx& ex1, const RegEx& ex2) {
+  RegEx ret(REGEX_AND);
+  ret.m_params.push_back(ex1);
+  ret.m_params.push_back(ex2);
+  return ret;
+}
+
+RegEx operator+(const RegEx& ex1, const RegEx& ex2) {
+  RegEx ret(REGEX_SEQ);
+  ret.m_params.push_back(ex1);
+  ret.m_params.push_back(ex2);
+  return ret;
+}
+}  // namespace YAML

src/regex_yaml.h

@@ -0,0 +1,88 @@
+#ifndef REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) ||                                            \
+    (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+     (__GNUC__ >= 4))  // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <vector>
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+class Stream;
+
+enum REGEX_OP {
+  REGEX_EMPTY,
+  REGEX_MATCH,
+  REGEX_RANGE,
+  REGEX_OR,
+  REGEX_AND,
+  REGEX_NOT,
+  REGEX_SEQ
+};
+
+// simplified regular expressions
+// . Only straightforward matches (no repeated characters)
+// . Only matches from start of string
+class YAML_CPP_API RegEx {
+ public:
+  RegEx();
+  explicit RegEx(char ch);
+  RegEx(char a, char z);
+  RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
+  ~RegEx() = default;
+
+  friend YAML_CPP_API RegEx operator!(const RegEx& ex);
+  friend YAML_CPP_API RegEx operator|(const RegEx& ex1, const RegEx& ex2);
+  friend YAML_CPP_API RegEx operator&(const RegEx& ex1, const RegEx& ex2);
+  friend YAML_CPP_API RegEx operator+(const RegEx& ex1, const RegEx& ex2);
+
+  bool Matches(char ch) const;
+  bool Matches(const std::string& str) const;
+  bool Matches(const Stream& in) const;
+  template <typename Source>
+  bool Matches(const Source& source) const;
+
+  int Match(const std::string& str) const;
+  int Match(const Stream& in) const;
+  template <typename Source>
+  int Match(const Source& source) const;
+
+ private:
+  explicit RegEx(REGEX_OP op);
+
+  template <typename Source>
+  bool IsValidSource(const Source& source) const;
+  template <typename Source>
+  int MatchUnchecked(const Source& source) const;
+
+  template <typename Source>
+  int MatchOpEmpty(const Source& source) const;
+  template <typename Source>
+  int MatchOpMatch(const Source& source) const;
+  template <typename Source>
+  int MatchOpRange(const Source& source) const;
+  template <typename Source>
+  int MatchOpOr(const Source& source) const;
+  template <typename Source>
+  int MatchOpAnd(const Source& source) const;
+  template <typename Source>
+  int MatchOpNot(const Source& source) const;
+  template <typename Source>
+  int MatchOpSeq(const Source& source) const;
+
+ private:
+  REGEX_OP m_op;
+  char m_a{};
+  char m_z{};
+  std::vector<RegEx> m_params;
+};
+}  // namespace YAML
+
+#include "regeximpl.h"
+
+#endif  // REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/regeximpl.h

@@ -1,17 +1,17 @@
 #ifndef REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define REGEXIMPL_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 "stream.h"
-#include "stringsource.h"
 #include "streamcharsource.h"
+#include "stringsource.h"
 
-namespace YAML
+namespace YAML {
-{
 // query matches
 inline bool RegEx::Matches(char ch) const {
   std::string str;
@@ -23,9 +23,7 @@ namespace YAML
   return Match(str) >= 0;
 }
 
-	inline bool RegEx::Matches(const Stream& in) const {
+inline bool RegEx::Matches(const Stream& in) const { return Match(in) >= 0; }
-		return Match(in) >= 0;
-	}
 
 template <typename Source>
 inline bool RegEx::Matches(const Source& source) const {
@@ -39,27 +37,24 @@ namespace YAML
 //   not returning zero is that we may have an empty regex
 //   which is ALWAYS successful at matching zero characters).
 // . REMEMBER that we only match from the start of the buffer!
-	inline int RegEx::Match(const std::string& str) const
+inline int RegEx::Match(const std::string& str) const {
-	{
   StringCharSource source(str.c_str(), str.size());
   return Match(source);
 }
 
-	inline int RegEx::Match(const Stream& in) const
+inline int RegEx::Match(const Stream& in) const {
-	{
   StreamCharSource source(in);
   return Match(source);
 }
 
 template <typename Source>
-	inline bool RegEx::IsValidSource(const Source& source) const
+inline bool RegEx::IsValidSource(const Source& source) const {
-	{
   return source;
 }
 
 template <>
-	inline bool RegEx::IsValidSource<StringCharSource>(const StringCharSource&source) const
+inline bool RegEx::IsValidSource<StringCharSource>(
-	{
+    const StringCharSource& source) const {
   switch (m_op) {
     case REGEX_MATCH:
     case REGEX_RANGE:
@@ -70,14 +65,12 @@ namespace YAML
 }
 
 template <typename Source>
-	inline int RegEx::Match(const Source& source) const
+inline int RegEx::Match(const Source& source) const {
-	{
   return IsValidSource(source) ? MatchUnchecked(source) : -1;
 }
 
 template <typename Source>
-	inline int RegEx::MatchUnchecked(const Source& source) const
+inline int RegEx::MatchUnchecked(const Source& source) const {
-	{
   switch (m_op) {
     case REGEX_EMPTY:
       return MatchOpEmpty(source);
@@ -100,7 +93,8 @@ namespace YAML
 
 //////////////////////////////////////////////////////////////////////////////
 // Operators
-	// Note: the convention MatchOp*<Source> is that we can assume IsSourceValid(source).
+// Note: the convention MatchOp*<Source> is that we can assume
+// IsSourceValid(source).
 //       So we do all our checks *before* we call these functions
 
 // EmptyOperator
@@ -110,8 +104,10 @@ namespace YAML
 }
 
 template <>
-	inline int RegEx::MatchOpEmpty<StringCharSource>(const StringCharSource& source) const {
+inline int RegEx::MatchOpEmpty<StringCharSource>(
-		return !source ? 0 : -1;  // the empty regex only is successful on the empty string
+    const StringCharSource& source) const {
+  return !source ? 0 : -1;  // the empty regex only is successful on the empty
+                            // string
 }
 
 // MatchOperator
@@ -133,8 +129,8 @@ namespace YAML
 // OrOperator
 template <typename Source>
 inline int RegEx::MatchOpOr(const Source& source) const {
-		for(std::size_t i=0;i<m_params.size();i++) {
+  for (const RegEx& param : m_params) {
-			int n = m_params[i].MatchUnchecked(source);
+    int n = param.MatchUnchecked(source);
     if (n >= 0)
       return n;
   }
@@ -172,8 +168,11 @@ namespace YAML
 template <typename Source>
 inline int RegEx::MatchOpSeq(const Source& source) const {
   int offset = 0;
-		for(std::size_t i=0;i<m_params.size();i++) {
+  for (const RegEx& param : m_params) {
-			int n = m_params[i].Match(source + offset); // note Match, not MatchUnchecked because we need to check validity after the offset
+    int n = param.Match(source + offset);  // note Match, not
+                                           // MatchUnchecked because we
+                                           // need to check validity after
+                                           // the offset
     if (n == -1)
       return -1;
     offset += n;
@@ -181,6 +180,6 @@ namespace YAML
 
   return offset;
 }
-}
+}  // namespace YAML
 
 #endif  // REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/scanner.cpp

@@ -1,44 +1,41 @@
-#include "scanner.h"
-#include "token.h"
-#include "yaml-cpp/exceptions.h"
-#include "exp.h"
 #include <cassert>
 #include <memory>
 
-namespace YAML
+#include "exp.h"
-{
+#include "scanner.h"
+#include "token.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+
+namespace YAML {
 Scanner::Scanner(std::istream& in)
-		: INPUT(in), m_startedStream(false), m_endedStream(false), m_simpleKeyAllowed(false), m_canBeJSONFlow(false)
+    : INPUT(in),
-	{
+      m_tokens{},
-	}
+      m_startedStream(false),
+      m_endedStream(false),
+      m_simpleKeyAllowed(false),
+      m_canBeJSONFlow(false),
+      m_simpleKeys{},
+      m_indents{},
+      m_indentRefs{},
+      m_flows{} {}
 
-	Scanner::~Scanner()
+Scanner::~Scanner() = default;
-	{
-	}
 
-	// empty
+bool Scanner::empty() {
-	// . Returns true if there are no more tokens to be read
-	bool Scanner::empty()
-	{
   EnsureTokensInQueue();
   return m_tokens.empty();
 }
 
-	// pop
+void Scanner::pop() {
-	// . Simply removes the next token on the queue.
-	void Scanner::pop()
-	{
   EnsureTokensInQueue();
   if (!m_tokens.empty())
     m_tokens.pop();
 }
 
-	// peek
+Token& Scanner::peek() {
-	// . Returns (but does not remove) the next token on the queue.
-	Token& Scanner::peek()
-	{
   EnsureTokensInQueue();
-		assert(!m_tokens.empty());  // should we be asserting here? I mean, we really just be checking
+  assert(!m_tokens.empty());  // should we be asserting here? I mean, we really
+                              // just be checking
                               // if it's empty before peeking.
 
 #if 0
@@ -51,25 +48,17 @@ namespace YAML
   return m_tokens.front();
 }
 
-    // mark
+Mark Scanner::mark() const { return INPUT.mark(); }
-    // . Returns the current mark in the stream
-    Mark Scanner::mark() const
-    {
-        return INPUT.mark();
-    }
 
-	// EnsureTokensInQueue
+void Scanner::EnsureTokensInQueue() {
-	// . Scan until there's a valid token at the front of the queue,
-	//   or we're sure the queue is empty.
-	void Scanner::EnsureTokensInQueue()
-	{
   while (1) {
     if (!m_tokens.empty()) {
       Token& token = m_tokens.front();
 
       // if this guy's valid, then we're done
-				if(token.status == Token::VALID)
+      if (token.status == Token::VALID) {
         return;
+      }
 
       // here's where we clean up the impossible tokens
       if (token.status == Token::INVALID) {
@@ -81,24 +70,23 @@ namespace YAML
     }
 
     // no token? maybe we've actually finished
-			if(m_endedStream)
+    if (m_endedStream) {
       return;
+    }
 
     // no? then scan...
     ScanNextToken();
   }
 }
 
-	// ScanNextToken
+void Scanner::ScanNextToken() {
-	// . The main scanning function; here we branch out and
+  if (m_endedStream) {
-	//   scan whatever the next token should be.
-	void Scanner::ScanNextToken()
-	{
-		if(m_endedStream)
     return;
+  }
 
-		if(!m_startedStream)
+  if (!m_startedStream) {
     return StartStream();
+  }
 
   // get rid of whitespace, etc. (in between tokens it should be irrelevent)
   ScanToNextToken();
@@ -111,84 +99,102 @@ namespace YAML
   // *****
 
   // end of stream
-		if(!INPUT)
+  if (!INPUT) {
     return EndStream();
+  }
 
-		if(INPUT.column() == 0 && INPUT.peek() == Keys::Directive)
+  if (INPUT.column() == 0 && INPUT.peek() == Keys::Directive) {
     return ScanDirective();
+  }
 
   // document token
-		if(INPUT.column() == 0 && Exp::DocStart().Matches(INPUT))
+  if (INPUT.column() == 0 && Exp::DocStart().Matches(INPUT)) {
     return ScanDocStart();
+  }
 
-		if(INPUT.column() == 0 && Exp::DocEnd().Matches(INPUT))
+  if (INPUT.column() == 0 && Exp::DocEnd().Matches(INPUT)) {
     return ScanDocEnd();
+  }
 
   // flow start/end/entry
-		if(INPUT.peek() == Keys::FlowSeqStart || INPUT.peek() == Keys::FlowMapStart)
+  if (INPUT.peek() == Keys::FlowSeqStart ||
+      INPUT.peek() == Keys::FlowMapStart) {
     return ScanFlowStart();
+  }
 
-		if(INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd)
+  if (INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd) {
     return ScanFlowEnd();
+  }
 
-		if(INPUT.peek() == Keys::FlowEntry)
+  if (INPUT.peek() == Keys::FlowEntry) {
     return ScanFlowEntry();
+  }
 
   // block/map stuff
-		if(Exp::BlockEntry().Matches(INPUT))
+  if (Exp::BlockEntry().Matches(INPUT)) {
     return ScanBlockEntry();
+  }
 
-		if((InBlockContext() ? Exp::Key() : Exp::KeyInFlow()).Matches(INPUT))
+  if ((InBlockContext() ? Exp::Key() : Exp::KeyInFlow()).Matches(INPUT)) {
     return ScanKey();
+  }
 
-		if(GetValueRegex().Matches(INPUT))
+  if (GetValueRegex().Matches(INPUT)) {
     return ScanValue();
+  }
 
   // alias/anchor
-		if(INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor)
+  if (INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor) {
     return ScanAnchorOrAlias();
+  }
 
   // tag
-		if(INPUT.peek() == Keys::Tag)
+  if (INPUT.peek() == Keys::Tag) {
     return ScanTag();
+  }
 
   // special scalars
-		if(InBlockContext() && (INPUT.peek() == Keys::LiteralScalar || INPUT.peek() == Keys::FoldedScalar))
+  if (InBlockContext() && (INPUT.peek() == Keys::LiteralScalar ||
+                           INPUT.peek() == Keys::FoldedScalar)) {
     return ScanBlockScalar();
+  }
 
-		if(INPUT.peek() == '\'' || INPUT.peek() == '\"')
+  if (INPUT.peek() == '\'' || INPUT.peek() == '\"') {
     return ScanQuotedScalar();
+  }
 
   // plain scalars
-		if((InBlockContext() ? Exp::PlainScalar() : Exp::PlainScalarInFlow()).Matches(INPUT))
+  if ((InBlockContext() ? Exp::PlainScalar() : Exp::PlainScalarInFlow())
+          .Matches(INPUT)) {
     return ScanPlainScalar();
+  }
 
   // don't know what it is!
   throw ParserException(INPUT.mark(), ErrorMsg::UNKNOWN_TOKEN);
 }
 
-	// ScanToNextToken
+void Scanner::ScanToNextToken() {
-	// . Eats input until we reach the next token-like thing.
-	void Scanner::ScanToNextToken()
-	{
   while (1) {
     // first eat whitespace
     while (INPUT && IsWhitespaceToBeEaten(INPUT.peek())) {
-				if(InBlockContext() && Exp::Tab().Matches(INPUT))
+      if (InBlockContext() && Exp::Tab().Matches(INPUT)) {
         m_simpleKeyAllowed = false;
+      }
       INPUT.eat(1);
     }
 
     // then eat a comment
     if (Exp::Comment().Matches(INPUT)) {
       // eat until line break
-				while(INPUT && !Exp::Break().Matches(INPUT))
+      while (INPUT && !Exp::Break().Matches(INPUT)) {
         INPUT.eat(1);
       }
+    }
 
     // if it's NOT a line break, then we're done!
-			if(!Exp::Break().Matches(INPUT))
+    if (!Exp::Break().Matches(INPUT)) {
       break;
+    }
 
     // otherwise, let's eat the line break and keep going
     int n = Exp::Break().Match(INPUT);
@@ -198,10 +204,11 @@ namespace YAML
     InvalidateSimpleKey();
 
     // new line - we may be able to accept a simple key now
-			if(InBlockContext())
+    if (InBlockContext()) {
       m_simpleKeyAllowed = true;
     }
   }
+}
 
 ///////////////////////////////////////////////////////////////////////
 // Misc. helpers
@@ -210,49 +217,45 @@ namespace YAML
 // . We can eat whitespace if it's a space or tab
 // . Note: originally tabs in block context couldn't be eaten
 //         "where a simple key could be allowed
-	//         (i.e., not at the beginning of a line, or following '-', '?', or ':')"
+//         (i.e., not at the beginning of a line, or following '-', '?', or
+// ':')"
 //   I think this is wrong, since tabs can be non-content whitespace; it's just
 //   that they can't contribute to indentation, so once you've seen a tab in a
 //   line, you can't start a simple key
-	bool Scanner::IsWhitespaceToBeEaten(char ch)
+bool Scanner::IsWhitespaceToBeEaten(char ch) {
-	{
+  if (ch == ' ') {
-		if(ch == ' ')
     return true;
+  }
 
-		if(ch == '\t')
+  if (ch == '\t') {
     return true;
+  }
 
   return false;
 }
 
-	// GetValueRegex
+const RegEx& Scanner::GetValueRegex() const {
-	// . Get the appropriate regex to check if it's a value token
+  if (InBlockContext()) {
-	const RegEx& Scanner::GetValueRegex() const
-	{
-		if(InBlockContext())
     return Exp::Value();
+  }
 
   return m_canBeJSONFlow ? Exp::ValueInJSONFlow() : Exp::ValueInFlow();
 }
 
-	// StartStream
+void Scanner::StartStream() {
-	// . Set the initial conditions for starting a stream.
-	void Scanner::StartStream()
-	{
   m_startedStream = true;
   m_simpleKeyAllowed = true;
-		std::auto_ptr<IndentMarker> pIndent(new IndentMarker(-1, IndentMarker::NONE));
+  std::unique_ptr<IndentMarker> pIndent(
-		m_indentRefs.push_back(pIndent);
+      new IndentMarker(-1, IndentMarker::NONE));
+  m_indentRefs.push_back(std::move(pIndent));
   m_indents.push(&m_indentRefs.back());
 }
 
-	// EndStream
+void Scanner::EndStream() {
-	// . Close out the stream, finish up, etc.
-	void Scanner::EndStream()
-	{
   // force newline
-		if(INPUT.column() > 0)
+  if (INPUT.column() > 0) {
     INPUT.ResetColumn();
+  }
 
   PopAllIndents();
   PopAllSimpleKeys();
@@ -261,100 +264,100 @@ namespace YAML
   m_endedStream = true;
 }
 
-	Token *Scanner::PushToken(Token::TYPE type)
+Token* Scanner::PushToken(Token::TYPE type) {
-	{
   m_tokens.push(Token(type, INPUT.mark()));
   return &m_tokens.back();
 }
 
-	Token::TYPE Scanner::GetStartTokenFor(IndentMarker::INDENT_TYPE type) const
+Token::TYPE Scanner::GetStartTokenFor(IndentMarker::INDENT_TYPE type) const {
-	{
   switch (type) {
-			case IndentMarker::SEQ: return Token::BLOCK_SEQ_START;
+    case IndentMarker::SEQ:
-			case IndentMarker::MAP: return Token::BLOCK_MAP_START;
+      return Token::BLOCK_SEQ_START;
-			case IndentMarker::NONE: assert(false); break;
+    case IndentMarker::MAP:
+      return Token::BLOCK_MAP_START;
+    case IndentMarker::NONE:
+      assert(false);
+      break;
   }
   assert(false);
   throw std::runtime_error("yaml-cpp: internal error, invalid indent type");
 }
 
-	// PushIndentTo
+Scanner::IndentMarker* Scanner::PushIndentTo(int column,
-	// . Pushes an indentation onto the stack, and enqueues the
+                                             IndentMarker::INDENT_TYPE type) {
-	//   proper token (sequence start or mapping start).
-	// . Returns the indent marker it generates (if any).
-	Scanner::IndentMarker *Scanner::PushIndentTo(int column, IndentMarker::INDENT_TYPE type)
-	{
   // are we in flow?
-		if(InFlowContext())
+  if (InFlowContext()) {
-			return 0;
+    return nullptr;
+  }
 
-		std::auto_ptr<IndentMarker> pIndent(new IndentMarker(column, type));
+  std::unique_ptr<IndentMarker> pIndent(new IndentMarker(column, type));
   IndentMarker& indent = *pIndent;
   const IndentMarker& lastIndent = *m_indents.top();
 
   // is this actually an indentation?
-		if(indent.column < lastIndent.column)
+  if (indent.column < lastIndent.column) {
-			return 0;
+    return nullptr;
-		if(indent.column == lastIndent.column && !(indent.type == IndentMarker::SEQ && lastIndent.type == IndentMarker::MAP))
+  }
-			return 0;
+  if (indent.column == lastIndent.column &&
+      !(indent.type == IndentMarker::SEQ &&
+        lastIndent.type == IndentMarker::MAP)) {
+    return nullptr;
+  }
 
   // push a start token
   indent.pStartToken = PushToken(GetStartTokenFor(type));
 
   // and then the indent
   m_indents.push(&indent);
-		m_indentRefs.push_back(pIndent);
+  m_indentRefs.push_back(std::move(pIndent));
   return &m_indentRefs.back();
 }
 
-	// PopIndentToHere
+void Scanner::PopIndentToHere() {
-	// . Pops indentations off the stack until we reach the current indentation level,
-	//   and enqueues the proper token each time.
-	// . Then pops all invalid indentations off.
-	void Scanner::PopIndentToHere()
-	{
   // are we in flow?
-		if(InFlowContext())
+  if (InFlowContext()) {
     return;
+  }
 
   // now pop away
   while (!m_indents.empty()) {
     const IndentMarker& indent = *m_indents.top();
-			if(indent.column < INPUT.column())
+    if (indent.column < INPUT.column()) {
       break;
-			if(indent.column == INPUT.column() && !(indent.type == IndentMarker::SEQ && !Exp::BlockEntry().Matches(INPUT)))
+    }
+    if (indent.column == INPUT.column() &&
+        !(indent.type == IndentMarker::SEQ &&
+          !Exp::BlockEntry().Matches(INPUT))) {
       break;
+    }
 
     PopIndent();
   }
 
-		while(!m_indents.empty() && m_indents.top()->status == IndentMarker::INVALID)
+  while (!m_indents.empty() &&
+         m_indents.top()->status == IndentMarker::INVALID) {
     PopIndent();
   }
+}
 
-	// PopAllIndents
+void Scanner::PopAllIndents() {
-	// . Pops all indentations (except for the base empty one) off the stack,
-	//   and enqueues the proper token each time.
-	void Scanner::PopAllIndents()
-	{
   // are we in flow?
-		if(InFlowContext())
+  if (InFlowContext()) {
     return;
+  }
 
   // now pop away
   while (!m_indents.empty()) {
     const IndentMarker& indent = *m_indents.top();
-			if(indent.type == IndentMarker::NONE)
+    if (indent.type == IndentMarker::NONE) {
       break;
+    }
 
     PopIndent();
   }
 }
 
-	// PopIndent
+void Scanner::PopIndent() {
-	// . Pops a single indent, pushing the proper token
-	void Scanner::PopIndent()
-	{
   const IndentMarker& indent = *m_indents.top();
   m_indents.pop();
 
@@ -363,26 +366,21 @@ namespace YAML
     return;
   }
 
-		if(indent.type == IndentMarker::SEQ)
+  if (indent.type == IndentMarker::SEQ) {
     m_tokens.push(Token(Token::BLOCK_SEQ_END, INPUT.mark()));
-		else if(indent.type == IndentMarker::MAP)
+  } else if (indent.type == IndentMarker::MAP) {
     m_tokens.push(Token(Token::BLOCK_MAP_END, INPUT.mark()));
   }
+}
 
-	// GetTopIndent
+int Scanner::GetTopIndent() const {
-	int Scanner::GetTopIndent() const
+  if (m_indents.empty()) {
-	{
-		if(m_indents.empty())
     return 0;
+  }
   return m_indents.top()->column;
 }
 
-	// ThrowParserException
+void Scanner::ThrowParserException(const std::string& msg) const {
-	// . Throws a ParserException with the current token location
-	//   (if available).
-	// . Does not parse any more tokens.
-	void Scanner::ThrowParserException(const std::string& msg) const
-	{
   Mark mark = Mark::null_mark();
   if (!m_tokens.empty()) {
     const Token& token = m_tokens.front();
@@ -390,5 +388,4 @@ namespace YAML
   }
   throw ParserException(mark, msg);
 }
-}
+}  // namespace YAML
-

src/scanner.h

@@ -1,43 +1,55 @@
 #ifndef SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define SCANNER_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 <ios>
-#include <string>
-#include <queue>
-#include <stack>
-#include <set>
 #include <map>
+#include <queue>
+#include <set>
+#include <stack>
+#include <string>
+
 #include "ptr_vector.h"
 #include "stream.h"
 #include "token.h"
+#include "yaml-cpp/mark.h"
 
-namespace YAML
+namespace YAML {
-{
 class Node;
 class RegEx;
 
-	class Scanner
+/**
-	{
+ * A scanner transforms a stream of characters into a stream of tokens.
+ */
+class Scanner {
  public:
-		Scanner(std::istream& in);
+  explicit Scanner(std::istream &in);
   ~Scanner();
 
-		// token queue management (hopefully this looks kinda stl-ish)
+  /** Returns true if there are no more tokens to be read. */
   bool empty();
+
+  /** Removes the next token in the queue. */
   void pop();
+
+  /** Returns, but does not remove, the next token in the queue. */
   Token &peek();
+
+  /** Returns the current mark in the input stream. */
   Mark mark() const;
 
  private:
   struct IndentMarker {
     enum INDENT_TYPE { MAP, SEQ, NONE };
     enum STATUS { VALID, INVALID, UNKNOWN };
-			IndentMarker(int column_, INDENT_TYPE type_): column(column_), type(type_), status(VALID), pStartToken(0) {}
+    IndentMarker(int column_, INDENT_TYPE type_)
+        : column(column_), type(type_), status(VALID), pStartToken(nullptr) {}
 
     int column;
     INDENT_TYPE type;
@@ -49,21 +61,59 @@ namespace YAML
 
  private:
   // scanning
+
+  /**
+   * Scans until there's a valid token at the front of the queue, or the queue
+   * is empty. The state can be checked by {@link #empty}, and the next token
+   * retrieved by {@link #peek}.
+   */
   void EnsureTokensInQueue();
+
+  /**
+   * The main scanning function; this method branches out to scan whatever the
+   * next token should be.
+   */
   void ScanNextToken();
+
+  /** Eats the input stream until it reaches the next token-like thing. */
   void ScanToNextToken();
+
+  /** Sets the initial conditions for starting a stream. */
   void StartStream();
+
+  /** Closes out the stream, finish up, etc. */
   void EndStream();
+
   Token *PushToken(Token::TYPE type);
 
   bool InFlowContext() const { return !m_flows.empty(); }
   bool InBlockContext() const { return m_flows.empty(); }
-		int GetFlowLevel() const { return m_flows.size(); }
+  std::size_t GetFlowLevel() const { return m_flows.size(); }
 
   Token::TYPE GetStartTokenFor(IndentMarker::INDENT_TYPE type) const;
+
+  /**
+   * Pushes an indentation onto the stack, and enqueues the proper token
+   * (sequence start or mapping start).
+   *
+   * @return the indent marker it generates (if any).
+   */
   IndentMarker *PushIndentTo(int column, IndentMarker::INDENT_TYPE type);
+
+  /**
+   * Pops indentations off the stack until it reaches the current indentation
+   * level, and enqueues the proper token each time. Then pops all invalid
+   * indentations off.
+   */
   void PopIndentToHere();
+
+  /**
+   * Pops all indentations (except for the base empty one) off the stack, and
+   * enqueues the proper token each time.
+   */
   void PopAllIndents();
+
+  /** Pops a single indent, pushing the proper token. */
   void PopIndent();
   int GetTopIndent() const;
 
@@ -75,19 +125,27 @@ namespace YAML
   bool VerifySimpleKey();
   void PopAllSimpleKeys();
 
+  /**
+   * Throws a ParserException with the current token location (if available),
+   * and does not parse any more tokens.
+   */
   void ThrowParserException(const std::string &msg) const;
 
   bool IsWhitespaceToBeEaten(char ch);
+
+  /**
+   * Returns the appropriate regex to check if the next token is a value token.
+   */
   const RegEx &GetValueRegex() const;
 
   struct SimpleKey {
-			SimpleKey(const Mark& mark_, int flowLevel_);
+    SimpleKey(const Mark &mark_, std::size_t flowLevel_);
 
     void Validate();
     void Invalidate();
 
     Mark mark;
-			int flowLevel;
+    std::size_t flowLevel;
     IndentMarker *pIndent;
     Token *pMapStart, *pKey;
   };
@@ -130,4 +188,3 @@ namespace YAML
 }
 
 #endif  // SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

src/scanscalar.cpp

@@ -1,11 +1,13 @@
 #include "scanscalar.h"
-#include "scanner.h"
-#include "exp.h"
-#include "yaml-cpp/exceptions.h"
-#include "token.h"
 
-namespace YAML
+#include <algorithm>
-{
+
+#include "exp.h"
+#include "regeximpl.h"
+#include "stream.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+
+namespace YAML {
 // ScanScalar
 // . This is where the scalar magic happens.
 //
@@ -16,8 +18,7 @@ namespace YAML
 //
 // . Depending on the parameters given, we store or stop
 //   and different places in the above flow.
-	std::string ScanScalar(Stream& INPUT, ScanScalarParams& params)
+std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {
-	{
   bool foundNonEmptyLine = false;
   bool pastOpeningBreak = (params.fold == FOLD_FLOW);
   bool emptyLine = false, moreIndented = false;
@@ -27,23 +28,29 @@ namespace YAML
   std::string scalar;
   params.leadingSpaces = false;
 
+  if (!params.end) {
+    params.end = &Exp::Empty();
+  }
+
   while (INPUT) {
     // ********************************
     // Phase #1: scan until line ending
 
     std::size_t lastNonWhitespaceChar = scalar.size();
     bool escapedNewline = false;
-			while(!params.end.Matches(INPUT) && !Exp::Break().Matches(INPUT)) {
+    while (!params.end->Matches(INPUT) && !Exp::Break().Matches(INPUT)) {
-				if(!INPUT)
+      if (!INPUT) {
         break;
+      }
 
       // document indicator?
       if (INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT)) {
-					if(params.onDocIndicator == BREAK)
+        if (params.onDocIndicator == BREAK) {
           break;
-					else if(params.onDocIndicator == THROW)
+        } else if (params.onDocIndicator == THROW) {
           throw ParserException(INPUT.mark(), ErrorMsg::DOC_IN_SCALAR);
         }
+      }
 
       foundNonEmptyLine = true;
       pastOpeningBreak = true;
@@ -69,26 +76,31 @@ namespace YAML
       // otherwise, just add the damn character
       char ch = INPUT.get();
       scalar += ch;
-				if(ch != ' ' && ch != '\t')
+      if (ch != ' ' && ch != '\t') {
         lastNonWhitespaceChar = scalar.size();
       }
+    }
 
     // eof? if we're looking to eat something, then we throw
     if (!INPUT) {
-				if(params.eatEnd)
+      if (params.eatEnd) {
         throw ParserException(INPUT.mark(), ErrorMsg::EOF_IN_SCALAR);
+      }
       break;
     }
 
     // doc indicator?
-			if(params.onDocIndicator == BREAK && INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT))
+    if (params.onDocIndicator == BREAK && INPUT.column() == 0 &&
+        Exp::DocIndicator().Matches(INPUT)) {
       break;
+    }
 
     // are we done via character match?
-			int n = params.end.Match(INPUT);
+    int n = params.end->Match(INPUT);
     if (n >= 0) {
-				if(params.eatEnd)
+      if (params.eatEnd) {
         INPUT.eat(n);
+      }
       break;
     }
 
@@ -105,21 +117,33 @@ namespace YAML
     // Phase #3: scan initial spaces
 
     // first the required indentation
-			while(INPUT.peek() == ' ' && (INPUT.column() < params.indent || (params.detectIndent && !foundNonEmptyLine)))
+    while (INPUT.peek() == ' ' &&
+           (INPUT.column() < params.indent ||
+            (params.detectIndent && !foundNonEmptyLine)) &&
+           !params.end->Matches(INPUT)) {
       INPUT.eat(1);
+    }
 
     // update indent if we're auto-detecting
-			if(params.detectIndent && !foundNonEmptyLine)
+    if (params.detectIndent && !foundNonEmptyLine) {
       params.indent = std::max(params.indent, INPUT.column());
+    }
 
     // and then the rest of the whitespace
     while (Exp::Blank().Matches(INPUT)) {
       // we check for tabs that masquerade as indentation
-				if(INPUT.peek() == '\t'&& INPUT.column() < params.indent && params.onTabInIndentation == THROW)
+      if (INPUT.peek() == '\t' && INPUT.column() < params.indent &&
+          params.onTabInIndentation == THROW) {
         throw ParserException(INPUT.mark(), ErrorMsg::TAB_IN_INDENTATION);
+      }
 
-				if(!params.eatLeadingWhitespace)
+      if (!params.eatLeadingWhitespace) {
         break;
+      }
+
+      if (params.end->Matches(INPUT)) {
+        break;
+      }
 
       INPUT.eat(1);
     }
@@ -130,32 +154,38 @@ namespace YAML
     if (params.fold == FOLD_BLOCK && foldedNewlineCount == 0 && nextEmptyLine)
       foldedNewlineStartedMoreIndented = moreIndented;
 
-			// for block scalars, we always start with a newline, so we should ignore it (not fold or keep)
+    // for block scalars, we always start with a newline, so we should ignore it
+    // (not fold or keep)
     if (pastOpeningBreak) {
       switch (params.fold) {
         case DONT_FOLD:
           scalar += "\n";
           break;
         case FOLD_BLOCK:
-						if(!emptyLine && !nextEmptyLine && !moreIndented && !nextMoreIndented && INPUT.column() >= params.indent)
+          if (!emptyLine && !nextEmptyLine && !moreIndented &&
+              !nextMoreIndented && INPUT.column() >= params.indent) {
             scalar += " ";
-						else if(nextEmptyLine)
+          } else if (nextEmptyLine) {
             foldedNewlineCount++;
-						else
+          } else {
             scalar += "\n";
+          }
 
           if (!nextEmptyLine && foldedNewlineCount > 0) {
             scalar += std::string(foldedNewlineCount - 1, '\n');
-							if(foldedNewlineStartedMoreIndented || nextMoreIndented | !foundNonEmptyLine)
+            if (foldedNewlineStartedMoreIndented ||
+                nextMoreIndented | !foundNonEmptyLine) {
               scalar += "\n";
+            }
             foldedNewlineCount = 0;
           }
           break;
         case FOLD_FLOW:
-						if(nextEmptyLine)
+          if (nextEmptyLine) {
             scalar += "\n";
-						else if(!emptyLine && !nextEmptyLine && !escapedNewline)
+          } else if (!emptyLine && !escapedNewline) {
             scalar += " ";
+          }
           break;
       }
     }
@@ -175,35 +205,41 @@ namespace YAML
   if (params.trimTrailingSpaces) {
     std::size_t pos = scalar.find_last_not_of(' ');
     if (lastEscapedChar != std::string::npos) {
-                if(pos < lastEscapedChar || pos == std::string::npos)
+      if (pos < lastEscapedChar || pos == std::string::npos) {
         pos = lastEscapedChar;
       }
-			if(pos < scalar.size())
+    }
+    if (pos < scalar.size()) {
       scalar.erase(pos + 1);
     }
+  }
 
   switch (params.chomp) {
     case CLIP: {
       std::size_t pos = scalar.find_last_not_of('\n');
       if (lastEscapedChar != std::string::npos) {
-                    if(pos < lastEscapedChar || pos == std::string::npos)
+        if (pos < lastEscapedChar || pos == std::string::npos) {
           pos = lastEscapedChar;
         }
-				if(pos == std::string::npos)
+      }
+      if (pos == std::string::npos) {
         scalar.erase();
-				else if(pos + 1 < scalar.size())
+      } else if (pos + 1 < scalar.size()) {
         scalar.erase(pos + 2);
+      }
     } break;
     case STRIP: {
       std::size_t pos = scalar.find_last_not_of('\n');
       if (lastEscapedChar != std::string::npos) {
-                    if(pos < lastEscapedChar || pos == std::string::npos)
+        if (pos < lastEscapedChar || pos == std::string::npos) {
           pos = lastEscapedChar;
         }
-				if(pos == std::string::npos)
+      }
+      if (pos == std::string::npos) {
         scalar.erase();
-				else if(pos < scalar.size())
+      } else if (pos < scalar.size()) {
         scalar.erase(pos + 1);
+      }
     } break;
     default:
       break;

src/scanscalar.h

@@ -1,38 +1,57 @@
 #ifndef SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define SCANSCALAR_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 "regex.h"
+
+#include "regex_yaml.h"
 #include "stream.h"
 
-namespace YAML
+namespace YAML {
-{
 enum CHOMP { STRIP = -1, CLIP, KEEP };
 enum ACTION { NONE, BREAK, THROW };
 enum FOLD { DONT_FOLD, FOLD_BLOCK, FOLD_FLOW };
 
 struct ScanScalarParams {
-		ScanScalarParams(): eatEnd(false), indent(0), detectIndent(false), eatLeadingWhitespace(0), escape(0), fold(DONT_FOLD),
+  ScanScalarParams()
-			trimTrailingSpaces(0), chomp(CLIP), onDocIndicator(NONE), onTabInIndentation(NONE), leadingSpaces(false) {}
+      : end(nullptr),
+        eatEnd(false),
+        indent(0),
+        detectIndent(false),
+        eatLeadingWhitespace(0),
+        escape(0),
+        fold(DONT_FOLD),
+        trimTrailingSpaces(0),
+        chomp(CLIP),
+        onDocIndicator(NONE),
+        onTabInIndentation(NONE),
+        leadingSpaces(false) {}
 
   // input:
-		RegEx end;                      // what condition ends this scalar?
+  const RegEx* end;   // what condition ends this scalar?
+                      // unowned.
   bool eatEnd;        // should we eat that condition when we see it?
   int indent;         // what level of indentation should be eaten and ignored?
   bool detectIndent;  // should we try to autodetect the indent?
-		bool eatLeadingWhitespace;      // should we continue eating this delicious indentation after 'indent' spaces?
+  bool eatLeadingWhitespace;  // should we continue eating this delicious
-		char escape;                    // what character do we escape on (i.e., slash or single quote) (0 for none)
+                              // indentation after 'indent' spaces?
+  char escape;  // what character do we escape on (i.e., slash or single quote)
+                // (0 for none)
   FOLD fold;    // how do we fold line ends?
-		bool trimTrailingSpaces;        // do we remove all trailing spaces (at the very end)
+  bool trimTrailingSpaces;  // do we remove all trailing spaces (at the very
-		CHOMP chomp;                    // do we strip, clip, or keep trailing newlines (at the very end)
+                            // end)
-		                                //   Note: strip means kill all, clip means keep at most one, keep means keep all
+  CHOMP chomp;  // do we strip, clip, or keep trailing newlines (at the very
+                // end)
+  //   Note: strip means kill all, clip means keep at most one, keep means keep
+  // all
   ACTION onDocIndicator;      // what do we do if we see a document indicator?
-		ACTION onTabInIndentation;      // what do we do if we see a tab where we should be seeing indentation spaces
+  ACTION onTabInIndentation;  // what do we do if we see a tab where we should
+                              // be seeing indentation spaces
 
   // output:
   bool leadingSpaces;
@@ -42,4 +61,3 @@ namespace YAML
 }
 
 #endif  // SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

src/scantag.cpp

@@ -1,12 +1,12 @@
-#include "scanner.h"
-#include "regex.h"
 #include "exp.h"
-#include "yaml-cpp/exceptions.h"
+#include "regex_yaml.h"
+#include "regeximpl.h"
+#include "stream.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+#include "yaml-cpp/mark.h"
 
-namespace YAML
+namespace YAML {
-{
+const std::string ScanVerbatimTag(Stream& INPUT) {
-	const std::string ScanVerbatimTag(Stream& INPUT)
-	{
   std::string tag;
 
   // eat the start character
@@ -29,8 +29,7 @@ namespace YAML
   throw ParserException(INPUT.mark(), ErrorMsg::END_OF_VERBATIM_TAG);
 }
 
-	const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle)
+const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle) {
-	{
   std::string tag;
   canBeHandle = true;
   Mark firstNonWordChar;
@@ -63,8 +62,7 @@ namespace YAML
   return tag;
 }
 
-	const std::string ScanTagSuffix(Stream& INPUT)
+const std::string ScanTagSuffix(Stream& INPUT) {
-	{
   std::string tag;
 
   while (INPUT) {
@@ -81,4 +79,3 @@ namespace YAML
   return tag;
 }
 }
-

src/scantag.h

@@ -1,20 +1,19 @@
 #ifndef SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define SCANTAG_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 "stream.h"
 
-namespace YAML
+namespace YAML {
-{
 const std::string ScanVerbatimTag(Stream& INPUT);
 const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle);
 const std::string ScanTagSuffix(Stream& INPUT);
 }
 
 #endif  // SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
-

src/scantoken.cpp

@@ -1,21 +1,23 @@
-#include "scanner.h"
-#include "token.h"
-#include "yaml-cpp/exceptions.h"
-#include "exp.h"
-#include "scanscalar.h"
-#include "scantag.h"
-#include "tag.h"
 #include <sstream>
 
-namespace YAML
+#include "exp.h"
-{
+#include "regex_yaml.h"
+#include "regeximpl.h"
+#include "scanner.h"
+#include "scanscalar.h"
+#include "scantag.h"  // IWYU pragma: keep
+#include "tag.h"      // IWYU pragma: keep
+#include "token.h"
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+#include "yaml-cpp/mark.h"
+
+namespace YAML {
 ///////////////////////////////////////////////////////////////////////
 // Specialization for scanning specific tokens
 
 // Directive
 // . Note: no semantic checking is done here (that's for the parser to do)
-	void Scanner::ScanDirective()
+void Scanner::ScanDirective() {
-	{
   std::string name;
   std::vector<std::string> params;
 
@@ -56,8 +58,7 @@ namespace YAML
 }
 
 // DocStart
-	void Scanner::ScanDocStart()
+void Scanner::ScanDocStart() {
-	{
   PopAllIndents();
   PopAllSimpleKeys();
   m_simpleKeyAllowed = false;
@@ -70,8 +71,7 @@ namespace YAML
 }
 
 // DocEnd
-	void Scanner::ScanDocEnd()
+void Scanner::ScanDocEnd() {
-	{
   PopAllIndents();
   PopAllSimpleKeys();
   m_simpleKeyAllowed = false;
@@ -84,8 +84,7 @@ namespace YAML
 }
 
 // FlowStart
-	void Scanner::ScanFlowStart()
+void Scanner::ScanFlowStart() {
-	{
   // flows can be simple keys
   InsertPotentialSimpleKey();
   m_simpleKeyAllowed = true;
@@ -96,13 +95,13 @@ namespace YAML
   char ch = INPUT.get();
   FLOW_MARKER flowType = (ch == Keys::FlowSeqStart ? FLOW_SEQ : FLOW_MAP);
   m_flows.push(flowType);
-		Token::TYPE type = (flowType == FLOW_SEQ ? Token::FLOW_SEQ_START : Token::FLOW_MAP_START);
+  Token::TYPE type =
+      (flowType == FLOW_SEQ ? Token::FLOW_SEQ_START : Token::FLOW_MAP_START);
   m_tokens.push(Token(type, mark));
 }
 
 // FlowEnd
-	void Scanner::ScanFlowEnd()
+void Scanner::ScanFlowEnd() {
-	{
   if (InBlockContext())
     throw ParserException(INPUT.mark(), ErrorMsg::FLOW_END);
 
@@ -132,8 +131,7 @@ namespace YAML
 }
 
 // FlowEntry
-	void Scanner::ScanFlowEntry()
+void Scanner::ScanFlowEntry() {
-	{
   // we might have a solo entry in the flow context
   if (InFlowContext()) {
     if (m_flows.top() == FLOW_MAP && VerifySimpleKey())
@@ -152,8 +150,7 @@ namespace YAML
 }
 
 // BlockEntry
-	void Scanner::ScanBlockEntry()
+void Scanner::ScanBlockEntry() {
-	{
   // we better be in the block context!
   if (InFlowContext())
     throw ParserException(INPUT.mark(), ErrorMsg::BLOCK_ENTRY);
@@ -173,8 +170,7 @@ namespace YAML
 }
 
 // Key
-	void Scanner::ScanKey()
+void Scanner::ScanKey() {
-	{
   // handle keys diffently in the block context (and manage indents)
   if (InBlockContext()) {
     if (!m_simpleKeyAllowed)
@@ -193,14 +189,14 @@ namespace YAML
 }
 
 // Value
-	void Scanner::ScanValue()
+void Scanner::ScanValue() {
-	{
   // and check that simple key
   bool isSimpleKey = VerifySimpleKey();
   m_canBeJSONFlow = false;
 
   if (isSimpleKey) {
-			// can't follow a simple key with another simple key (dunno why, though - it seems fine)
+    // can't follow a simple key with another simple key (dunno why, though - it
+    // seems fine)
     m_simpleKeyAllowed = false;
   } else {
     // handle values diffently in the block context (and manage indents)
@@ -222,8 +218,7 @@ namespace YAML
 }
 
 // AnchorOrAlias
-	void Scanner::ScanAnchorOrAlias()
+void Scanner::ScanAnchorOrAlias() {
-	{
   bool alias;
   std::string name;
 
@@ -243,11 +238,13 @@ namespace YAML
 
   // we need to have read SOMETHING!
   if (name.empty())
-			throw ParserException(INPUT.mark(), alias ? ErrorMsg::ALIAS_NOT_FOUND : ErrorMsg::ANCHOR_NOT_FOUND);
+    throw ParserException(INPUT.mark(), alias ? ErrorMsg::ALIAS_NOT_FOUND
+                                              : ErrorMsg::ANCHOR_NOT_FOUND);
 
   // and needs to end correctly
   if (INPUT && !Exp::AnchorEnd().Matches(INPUT))
-			throw ParserException(INPUT.mark(), alias ? ErrorMsg::CHAR_IN_ALIAS : ErrorMsg::CHAR_IN_ANCHOR);
+    throw ParserException(INPUT.mark(), alias ? ErrorMsg::CHAR_IN_ALIAS
+                                              : ErrorMsg::CHAR_IN_ANCHOR);
 
   // and we're done
   Token token(alias ? Token::ALIAS : Token::ANCHOR, mark);
@@ -256,8 +253,7 @@ namespace YAML
 }
 
 // Tag
-	void Scanner::ScanTag()
+void Scanner::ScanTag() {
-	{
   // insert a potential simple key
   InsertPotentialSimpleKey();
   m_simpleKeyAllowed = false;
@@ -296,13 +292,13 @@ namespace YAML
 }
 
 // PlainScalar
-	void Scanner::ScanPlainScalar()
+void Scanner::ScanPlainScalar() {
-	{
   std::string scalar;
 
   // set up the scanning parameters
   ScanScalarParams params;
-		params.end = (InFlowContext() ? Exp::EndScalarInFlow() : Exp::EndScalar()) || (Exp::BlankOrBreak() + Exp::Comment());
+  params.end =
+      (InFlowContext() ? &Exp::ScanScalarEndInFlow() : &Exp::ScanScalarEnd());
   params.eatEnd = false;
   params.indent = (InFlowContext() ? 0 : GetTopIndent() + 1);
   params.fold = FOLD_FLOW;
@@ -332,17 +328,18 @@ namespace YAML
 }
 
 // QuotedScalar
-	void Scanner::ScanQuotedScalar()
+void Scanner::ScanQuotedScalar() {
-	{
   std::string scalar;
 
-		// peek at single or double quote (don't eat because we need to preserve (for the time being) the input position)
+  // peek at single or double quote (don't eat because we need to preserve (for
+  // the time being) the input position)
   char quote = INPUT.peek();
   bool single = (quote == '\'');
 
   // setup the scanning parameters
   ScanScalarParams params;
-		params.end = (single ? RegEx(quote) && !Exp::EscSingleQuote() : RegEx(quote));
+  RegEx end = (single ? RegEx(quote) & !Exp::EscSingleQuote() : RegEx(quote));
+  params.end = &end;
   params.eatEnd = true;
   params.escape = (single ? '\'' : '\\');
   params.indent = 0;
@@ -372,10 +369,10 @@ namespace YAML
 
 // BlockScalarToken
 // . These need a little extra processing beforehand.
-	// . We need to scan the line where the indicator is (this doesn't count as part of the scalar),
+// . We need to scan the line where the indicator is (this doesn't count as part
+// of the scalar),
 //   and then we need to figure out what level of indentation we'll be using.
-	void Scanner::ScanBlockScalar()
+void Scanner::ScanBlockScalar() {
-	{
   std::string scalar;
 
   ScanScalarParams params;
@@ -428,7 +425,8 @@ namespace YAML
 
   scalar = ScanScalar(INPUT, params);
 
-		// simple keys always ok after block scalars (since we're gonna start a new line anyways)
+  // simple keys always ok after block scalars (since we're gonna start a new
+  // line anyways)
   m_simpleKeyAllowed = true;
   m_canBeJSONFlow = false;
 
@@ -436,4 +434,4 @@ namespace YAML
   token.value = scalar;
   m_tokens.push(token);
 }
-}
+}  // namespace YAML

src/setting.h

@@ -1,54 +1,52 @@
 #ifndef SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define SETTING_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/noexcept.h"
 #include <memory>
+#include <utility>
 #include <vector>
-#include "yaml-cpp/noncopyable.h"
 
-namespace YAML
+namespace YAML {
-{
+
-	class SettingChangeBase;
+class SettingChangeBase {
+ public:
+  virtual ~SettingChangeBase() = default;
+  virtual void pop() = 0;
+};
 
 template <typename T>
-	class Setting
+class Setting {
-	{
  public:
   Setting() : m_value() {}
+  Setting(const T& value) : m_value() { set(value); }
 
   const T get() const { return m_value; }
-		std::auto_ptr <SettingChangeBase> set(const T& value);
+  std::unique_ptr<SettingChangeBase> set(const T& value);
-		void restore(const Setting<T>& oldSetting) {
+  void restore(const Setting<T>& oldSetting) { m_value = oldSetting.get(); }
-			m_value = oldSetting.get();
-		}
 
  private:
   T m_value;
 };
 
-	class SettingChangeBase
-	{
-	public:
-		virtual ~SettingChangeBase() {}
-		virtual void pop() = 0;
-	};
-	
 template <typename T>
-	class SettingChange: public SettingChangeBase
+class SettingChange : public SettingChangeBase {
-	{
  public:
-		SettingChange(Setting<T> *pSetting): m_pCurSetting(pSetting) {
+  SettingChange(Setting<T>* pSetting)
-			// copy old setting to save its state
+      : m_pCurSetting(pSetting),
-			m_oldSetting = *pSetting;
+        m_oldSetting(*pSetting)  // copy old setting to save its state
-		}
+  {}
+  SettingChange(const SettingChange&) = delete;
+  SettingChange(SettingChange&&) = delete;
+  SettingChange& operator=(const SettingChange&) = delete;
+  SettingChange& operator=(SettingChange&&) = delete;
 
-		virtual void pop() {
+  void pop() override { m_pCurSetting->restore(m_oldSetting); }
-			m_pCurSetting->restore(m_oldSetting);
-		}
 
  private:
   Setting<T>* m_pCurSetting;
@@ -56,50 +54,48 @@ namespace YAML
 };
 
 template <typename T>
-	inline std::auto_ptr <SettingChangeBase> Setting<T>::set(const T& value) {
+inline std::unique_ptr<SettingChangeBase> Setting<T>::set(const T& value) {
-		std::auto_ptr <SettingChangeBase> pChange(new SettingChange<T> (this));
+  std::unique_ptr<SettingChangeBase> pChange(new SettingChange<T>(this));
   m_value = value;
   return pChange;
 }
 
-	class SettingChanges: private noncopyable
+class SettingChanges {
-	{
  public:
-		SettingChanges() {}
+  SettingChanges() : m_settingChanges{} {}
-		~SettingChanges() { clear(); }
+  SettingChanges(const SettingChanges&) = delete;
-		
+  SettingChanges(SettingChanges&&) YAML_CPP_NOEXCEPT = default;
-		void clear() {
+  SettingChanges& operator=(const SettingChanges&) = delete;
-			restore();
+  SettingChanges& operator=(SettingChanges&& rhs) YAML_CPP_NOEXCEPT {
-			
-			for(setting_changes::const_iterator it=m_settingChanges.begin();it!=m_settingChanges.end();++it)
-				delete *it;
-			m_settingChanges.clear();
-		}
-		
-		void restore() {
-			for(setting_changes::const_iterator it=m_settingChanges.begin();it!=m_settingChanges.end();++it)
-				(*it)->pop();
-		}
-		
-		void push(std::auto_ptr <SettingChangeBase> pSettingChange) {
-			m_settingChanges.push_back(pSettingChange.release());
-		}
-		
-		// like std::auto_ptr - assignment is transfer of ownership
-		SettingChanges& operator = (SettingChanges& rhs) {
     if (this == &rhs)
       return *this;
 
     clear();
-			m_settingChanges = rhs.m_settingChanges;
+    std::swap(m_settingChanges, rhs.m_settingChanges);
-			rhs.m_settingChanges.clear();
+
     return *this;
   }
+  ~SettingChanges() { clear(); }
+
+  void clear() YAML_CPP_NOEXCEPT {
+    restore();
+    m_settingChanges.clear();
+  }
+
+  void restore() YAML_CPP_NOEXCEPT {
+    for (setting_changes::const_iterator it = m_settingChanges.begin();
+         it != m_settingChanges.end(); ++it)
+      (*it)->pop();
+  }
+
+  void push(std::unique_ptr<SettingChangeBase> pSettingChange) {
+    m_settingChanges.push_back(std::move(pSettingChange));
+  }
 
  private:
-		typedef std::vector <SettingChangeBase *> setting_changes;
+  using setting_changes = std::vector<std::unique_ptr<SettingChangeBase>>;
   setting_changes m_settingChanges;
 };
-}
+}  // namespace YAML
 
 #endif  // SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66

src/simplekey.cpp

@@ -1,17 +1,13 @@
 #include "scanner.h"
 #include "token.h"
-#include "yaml-cpp/exceptions.h"
-#include "exp.h"
 
-namespace YAML
+namespace YAML {
-{
+struct Mark;
-	Scanner::SimpleKey::SimpleKey(const Mark& mark_, int flowLevel_)
-		: mark(mark_), flowLevel(flowLevel_), pIndent(0), pMapStart(0), pKey(0)
-	{
-	}
 
-	void Scanner::SimpleKey::Validate()
+Scanner::SimpleKey::SimpleKey(const Mark& mark_, std::size_t flowLevel_)
-	{
+    : mark(mark_), flowLevel(flowLevel_), pIndent(nullptr), pMapStart(nullptr), pKey(nullptr) {}
+
+void Scanner::SimpleKey::Validate() {
   // Note: pIndent will *not* be garbage here;
   //       we "garbage collect" them so we can
   //       always refer to them
@@ -23,8 +19,7 @@ namespace YAML
     pKey->status = Token::VALID;
 }
 
-	void Scanner::SimpleKey::Invalidate()
+void Scanner::SimpleKey::Invalidate() {
-	{
   if (pIndent)
     pIndent->status = IndentMarker::INVALID;
   if (pMapStart)
@@ -34,8 +29,7 @@ namespace YAML
 }
 
 // CanInsertPotentialSimpleKey
-	bool Scanner::CanInsertPotentialSimpleKey() const
+bool Scanner::CanInsertPotentialSimpleKey() const {
-	{
   if (!m_simpleKeyAllowed)
     return false;
 
@@ -44,9 +38,9 @@ namespace YAML
 
 // ExistsActiveSimpleKey
 // . Returns true if there's a potential simple key at our flow level
-	//   (there's allowed at most one per flow level, i.e., at the start of the flow start token)
+//   (there's allowed at most one per flow level, i.e., at the start of the flow
-	bool Scanner::ExistsActiveSimpleKey() const
+// start token)
-	{
+bool Scanner::ExistsActiveSimpleKey() const {
   if (m_simpleKeys.empty())
     return false;
 
@@ -57,8 +51,7 @@ namespace YAML
 // InsertPotentialSimpleKey
 // . If we can, add a potential simple key to the queue,
 //   and save it on a stack.
-	void Scanner::InsertPotentialSimpleKey()
+void Scanner::InsertPotentialSimpleKey() {
-	{
   if (!CanInsertPotentialSimpleKey())
     return;
 
@@ -84,8 +77,7 @@ namespace YAML
 
 // InvalidateSimpleKey
 // . Automatically invalidate the simple key in our flow level
-	void Scanner::InvalidateSimpleKey()
+void Scanner::InvalidateSimpleKey() {
-	{
   if (m_simpleKeys.empty())
     return;
 
@@ -101,8 +93,7 @@ namespace YAML
 // VerifySimpleKey
 // . Determines whether the latest simple key to be added is valid,
 //   and if so, makes it valid.
-	bool Scanner::VerifySimpleKey()
+bool Scanner::VerifySimpleKey() {
-	{
   if (m_simpleKeys.empty())
     return false;
 
@@ -130,10 +121,8 @@ namespace YAML
   return isValid;
 }
 
-	void Scanner::PopAllSimpleKeys()
+void Scanner::PopAllSimpleKeys() {
-	{
   while (!m_simpleKeys.empty())
     m_simpleKeys.pop();
 }
 }
-

src/singledocparser.cpp

@@ -1,30 +1,32 @@
-#include "singledocparser.h"
+#include <algorithm>
-#include "collectionstack.h"
+#include <cstdio>
-#include "directives.h"
+#include <sstream>
-#include "yaml-cpp/eventhandler.h"
+
-#include "yaml-cpp/exceptions.h"
+#include "collectionstack.h"  // IWYU pragma: keep
 #include "scanner.h"
+#include "singledocparser.h"
 #include "tag.h"
 #include "token.h"
-#include <sstream>
+#include "yaml-cpp/emitterstyle.h"
-#include <cstdio>
+#include "yaml-cpp/eventhandler.h"
-#include <algorithm>
+#include "yaml-cpp/exceptions.h"  // IWYU pragma: keep
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/null.h"
 
-namespace YAML
+namespace YAML {
-{
+SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives)
-	SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives): m_scanner(scanner), m_directives(directives), m_pCollectionStack(new CollectionStack), m_curAnchor(0)
+    : m_scanner(scanner),
-	{
+      m_directives(directives),
-	}
+      m_pCollectionStack(new CollectionStack),
+      m_anchors{},
+      m_curAnchor(0) {}
 
-	SingleDocParser::~SingleDocParser()
+SingleDocParser::~SingleDocParser() = default;
-	{
-	}
 
 // HandleDocument
 // . Handles the next document
 // . Throws a ParserException on error.
-	void SingleDocParser::HandleDocument(EventHandler& eventHandler)
+void SingleDocParser::HandleDocument(EventHandler& eventHandler) {
-	{
   assert(!m_scanner.empty());  // guaranteed that there are tokens
   assert(!m_curAnchor);
 
@@ -44,8 +46,7 @@ namespace YAML
     m_scanner.pop();
 }
 
-	void SingleDocParser::HandleNode(EventHandler& eventHandler)
+void SingleDocParser::HandleNode(EventHandler& eventHandler) {
-	{
   // an empty node *is* a possibility
   if (m_scanner.empty()) {
     eventHandler.OnNull(m_scanner.mark(), NullAnchor);
@@ -57,7 +58,7 @@ namespace YAML
 
   // special case: a value node by itself must be a map, with no header
   if (m_scanner.peek().type == Token::VALUE) {
-			eventHandler.OnMapStart(mark, "?", NullAnchor);
+    eventHandler.OnMapStart(mark, "?", NullAnchor, EmitterStyle::Default);
     HandleMap(eventHandler);
     eventHandler.OnMapEnd();
     return;
@@ -71,11 +72,27 @@ namespace YAML
   }
 
   std::string tag;
+  std::string anchor_name;
   anchor_t anchor;
-		ParseProperties(tag, anchor);
+  ParseProperties(tag, anchor, anchor_name);
+
+  if (!anchor_name.empty())
+    eventHandler.OnAnchor(mark, anchor_name);
+
+  // after parsing properties, an empty node is again a possibility
+  if (m_scanner.empty()) {
+    eventHandler.OnNull(mark, anchor);
+    return;
+  }
 
   const Token& token = m_scanner.peek();
 
+  if (token.type == Token::PLAIN_SCALAR && IsNullString(token.value)) {
+    eventHandler.OnNull(mark, anchor);
+    m_scanner.pop();
+    return;
+  }
+
   // add non-specific tags
   if (tag.empty())
     tag = (token.type == Token::NON_PLAIN_SCALAR ? "!" : "?");
@@ -88,21 +105,30 @@ namespace YAML
       m_scanner.pop();
       return;
     case Token::FLOW_SEQ_START:
+      eventHandler.OnSequenceStart(mark, tag, anchor, EmitterStyle::Flow);
+      HandleSequence(eventHandler);
+      eventHandler.OnSequenceEnd();
+      return;
     case Token::BLOCK_SEQ_START:
-				eventHandler.OnSequenceStart(mark, tag, anchor);
+      eventHandler.OnSequenceStart(mark, tag, anchor, EmitterStyle::Block);
       HandleSequence(eventHandler);
       eventHandler.OnSequenceEnd();
       return;
     case Token::FLOW_MAP_START:
+      eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Flow);
+      HandleMap(eventHandler);
+      eventHandler.OnMapEnd();
+      return;
     case Token::BLOCK_MAP_START:
-				eventHandler.OnMapStart(mark, tag, anchor);
+      eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Block);
       HandleMap(eventHandler);
       eventHandler.OnMapEnd();
       return;
     case Token::KEY:
       // compact maps can only go in a flow sequence
-				if(m_pCollectionStack->GetCurCollectionType() == CollectionType::FlowSeq) {
+      if (m_pCollectionStack->GetCurCollectionType() ==
-					eventHandler.OnMapStart(mark, tag, anchor);
+          CollectionType::FlowSeq) {
+        eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Flow);
         HandleMap(eventHandler);
         eventHandler.OnMapEnd();
         return;
@@ -118,18 +144,21 @@ namespace YAML
     eventHandler.OnScalar(mark, tag, anchor, "");
 }
 
-	void SingleDocParser::HandleSequence(EventHandler& eventHandler)
+void SingleDocParser::HandleSequence(EventHandler& eventHandler) {
-	{
   // split based on start token
   switch (m_scanner.peek().type) {
-			case Token::BLOCK_SEQ_START: HandleBlockSequence(eventHandler); break;
+    case Token::BLOCK_SEQ_START:
-			case Token::FLOW_SEQ_START: HandleFlowSequence(eventHandler); break;
+      HandleBlockSequence(eventHandler);
-			default: break;
+      break;
+    case Token::FLOW_SEQ_START:
+      HandleFlowSequence(eventHandler);
+      break;
+    default:
+      break;
   }
 }
 
-	void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler)
+void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) {
-	{
   // eat start token
   m_scanner.pop();
   m_pCollectionStack->PushCollectionType(CollectionType::BlockSeq);
@@ -148,9 +177,10 @@ namespace YAML
 
     // check for null
     if (!m_scanner.empty()) {
-				const Token& token = m_scanner.peek();
+      const Token& nextToken = m_scanner.peek();
-				if(token.type == Token::BLOCK_ENTRY || token.type == Token::BLOCK_SEQ_END) {
+      if (nextToken.type == Token::BLOCK_ENTRY ||
-					eventHandler.OnNull(token.mark, NullAnchor);
+          nextToken.type == Token::BLOCK_SEQ_END) {
+        eventHandler.OnNull(nextToken.mark, NullAnchor);
         continue;
       }
     }
@@ -161,8 +191,7 @@ namespace YAML
   m_pCollectionStack->PopCollectionType(CollectionType::BlockSeq);
 }
 
-	void SingleDocParser::HandleFlowSequence(EventHandler& eventHandler)
+void SingleDocParser::HandleFlowSequence(EventHandler& eventHandler) {
-	{
   // eat start token
   m_scanner.pop();
   m_pCollectionStack->PushCollectionType(CollectionType::FlowSeq);
@@ -183,7 +212,8 @@ namespace YAML
     if (m_scanner.empty())
       throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW);
 
-			// now eat the separator (or could be a sequence end, which we ignore - but if it's neither, then it's a bad node)
+    // now eat the separator (or could be a sequence end, which we ignore - but
+    // if it's neither, then it's a bad node)
     Token& token = m_scanner.peek();
     if (token.type == Token::FLOW_ENTRY)
       m_scanner.pop();
@@ -194,20 +224,27 @@ namespace YAML
   m_pCollectionStack->PopCollectionType(CollectionType::FlowSeq);
 }
 
-	void SingleDocParser::HandleMap(EventHandler& eventHandler)
+void SingleDocParser::HandleMap(EventHandler& eventHandler) {
-	{
   // split based on start token
   switch (m_scanner.peek().type) {
-			case Token::BLOCK_MAP_START: HandleBlockMap(eventHandler); break;
+    case Token::BLOCK_MAP_START:
-			case Token::FLOW_MAP_START: HandleFlowMap(eventHandler); break;
+      HandleBlockMap(eventHandler);
-			case Token::KEY: HandleCompactMap(eventHandler); break;
+      break;
-			case Token::VALUE: HandleCompactMapWithNoKey(eventHandler); break;
+    case Token::FLOW_MAP_START:
-			default: break;
+      HandleFlowMap(eventHandler);
+      break;
+    case Token::KEY:
+      HandleCompactMap(eventHandler);
+      break;
+    case Token::VALUE:
+      HandleCompactMapWithNoKey(eventHandler);
+      break;
+    default:
+      break;
   }
 }
 
-	void SingleDocParser::HandleBlockMap(EventHandler& eventHandler)
+void SingleDocParser::HandleBlockMap(EventHandler& eventHandler) {
-	{
   // eat start token
   m_scanner.pop();
   m_pCollectionStack->PushCollectionType(CollectionType::BlockMap);
@@ -217,7 +254,8 @@ namespace YAML
       throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP);
 
     Token token = m_scanner.peek();
-			if(token.type != Token::KEY && token.type != Token::VALUE && token.type != Token::BLOCK_MAP_END)
+    if (token.type != Token::KEY && token.type != Token::VALUE &&
+        token.type != Token::BLOCK_MAP_END)
       throw ParserException(token.mark, ErrorMsg::END_OF_MAP);
 
     if (token.type == Token::BLOCK_MAP_END) {
@@ -245,8 +283,7 @@ namespace YAML
   m_pCollectionStack->PopCollectionType(CollectionType::BlockMap);
 }
 
-	void SingleDocParser::HandleFlowMap(EventHandler& eventHandler)
+void SingleDocParser::HandleFlowMap(EventHandler& eventHandler) {
-	{
   // eat start token
   m_scanner.pop();
   m_pCollectionStack->PushCollectionType(CollectionType::FlowMap);
@@ -256,6 +293,7 @@ namespace YAML
       throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW);
 
     Token& token = m_scanner.peek();
+    const Mark mark = token.mark;
     // first check for end
     if (token.type == Token::FLOW_MAP_END) {
       m_scanner.pop();
@@ -267,7 +305,7 @@ namespace YAML
       m_scanner.pop();
       HandleNode(eventHandler);
     } else {
-				eventHandler.OnNull(token.mark, NullAnchor);
+      eventHandler.OnNull(mark, NullAnchor);
     }
 
     // now grab value (optional)
@@ -275,13 +313,14 @@ namespace YAML
       m_scanner.pop();
       HandleNode(eventHandler);
     } else {
-				eventHandler.OnNull(token.mark, NullAnchor);
+      eventHandler.OnNull(mark, NullAnchor);
     }
 
     if (m_scanner.empty())
       throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW);
 
-			// now eat the separator (or could be a map end, which we ignore - but if it's neither, then it's a bad node)
+    // now eat the separator (or could be a map end, which we ignore - but if
+    // it's neither, then it's a bad node)
     Token& nextToken = m_scanner.peek();
     if (nextToken.type == Token::FLOW_ENTRY)
       m_scanner.pop();
@@ -293,8 +332,7 @@ namespace YAML
 }
 
 // . Single "key: value" pair in a flow sequence
-	void SingleDocParser::HandleCompactMap(EventHandler& eventHandler)
+void SingleDocParser::HandleCompactMap(EventHandler& eventHandler) {
-	{
   m_pCollectionStack->PushCollectionType(CollectionType::CompactMap);
 
   // grab key
@@ -314,8 +352,7 @@ namespace YAML
 }
 
 // . Single ": value" pair in a flow sequence
-	void SingleDocParser::HandleCompactMapWithNoKey(EventHandler& eventHandler)
+void SingleDocParser::HandleCompactMapWithNoKey(EventHandler& eventHandler) {
-	{
   m_pCollectionStack->PushCollectionType(CollectionType::CompactMap);
 
   // null key
@@ -330,9 +367,10 @@ namespace YAML
 
 // ParseProperties
 // . Grabs any tag or anchor tokens and deals with them.
-	void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor)
+void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor,
-	{
+                                      std::string& anchor_name) {
   tag.clear();
+  anchor_name.clear();
   anchor = NullAnchor;
 
   while (1) {
@@ -340,15 +378,19 @@ namespace YAML
       return;
 
     switch (m_scanner.peek().type) {
-				case Token::TAG: ParseTag(tag); break;
+      case Token::TAG:
-				case Token::ANCHOR: ParseAnchor(anchor); break;
+        ParseTag(tag);
-				default: return;
+        break;
+      case Token::ANCHOR:
+        ParseAnchor(anchor, anchor_name);
+        break;
+      default:
+        return;
     }
   }
 }
 
-	void SingleDocParser::ParseTag(std::string& tag)
+void SingleDocParser::ParseTag(std::string& tag) {
-	{
   Token& token = m_scanner.peek();
   if (!tag.empty())
     throw ParserException(token.mark, ErrorMsg::MULTIPLE_TAGS);
@@ -358,30 +400,29 @@ namespace YAML
   m_scanner.pop();
 }
 
-	void SingleDocParser::ParseAnchor(anchor_t& anchor)
+void SingleDocParser::ParseAnchor(anchor_t& anchor, std::string& anchor_name) {
-	{
   Token& token = m_scanner.peek();
   if (anchor)
     throw ParserException(token.mark, ErrorMsg::MULTIPLE_ANCHORS);
 
+  anchor_name = token.value;
   anchor = RegisterAnchor(token.value);
   m_scanner.pop();
 }
 
-	anchor_t SingleDocParser::RegisterAnchor(const std::string& name)
+anchor_t SingleDocParser::RegisterAnchor(const std::string& name) {
-	{
   if (name.empty())
     return NullAnchor;
 
   return m_anchors[name] = ++m_curAnchor;
 }
 
-	anchor_t SingleDocParser::LookupAnchor(const Mark& mark, const std::string& name) const
+anchor_t SingleDocParser::LookupAnchor(const Mark& mark,
-	{
+                                       const std::string& name) const {
   Anchors::const_iterator it = m_anchors.find(name);
   if (it == m_anchors.end())
     throw ParserException(mark, ErrorMsg::UNKNOWN_ANCHOR);
 
   return it->second;
 }
-}
+}  // namespace YAML

src/singledocparser.h

@@ -1,31 +1,34 @@
 #ifndef SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
 #define SINGLEDOCPARSER_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 "yaml-cpp/noncopyable.h"
-#include <string>
 #include <map>
 #include <memory>
+#include <string>
 
-namespace YAML
+#include "yaml-cpp/anchor.h"
-{
+
-	struct Directives;
+namespace YAML {
-	struct Mark;
-	struct Token;
 class CollectionStack;
 class EventHandler;
 class Node;
 class Scanner;
+struct Directives;
+struct Mark;
+struct Token;
 
-	class SingleDocParser: private noncopyable
+class SingleDocParser {
-	{
  public:
   SingleDocParser(Scanner& scanner, const Directives& directives);
+  SingleDocParser(const SingleDocParser&) = delete;
+  SingleDocParser(SingleDocParser&&) = delete;
+  SingleDocParser& operator=(const SingleDocParser&) = delete;
+  SingleDocParser& operator=(SingleDocParser&&) = delete;
   ~SingleDocParser();
 
   void HandleDocument(EventHandler& eventHandler);
@@ -43,9 +46,10 @@ namespace YAML
   void HandleCompactMap(EventHandler& eventHandler);
   void HandleCompactMapWithNoKey(EventHandler& eventHandler);
 
-		void ParseProperties(std::string& tag, anchor_t& anchor);
+  void ParseProperties(std::string& tag, anchor_t& anchor,
+                       std::string& anchor_name);
   void ParseTag(std::string& tag);
-		void ParseAnchor(anchor_t& anchor);
+  void ParseAnchor(anchor_t& anchor, std::string& anchor_name);
 
   anchor_t RegisterAnchor(const std::string& name);
   anchor_t LookupAnchor(const Mark& mark, const std::string& name) const;
@@ -53,13 +57,13 @@ namespace YAML
  private:
   Scanner& m_scanner;
   const Directives& m_directives;
-		std::auto_ptr<CollectionStack> m_pCollectionStack;
+  std::unique_ptr<CollectionStack> m_pCollectionStack;
 
-		typedef std::map<std::string, anchor_t> Anchors;
+  using Anchors = std::map<std::string, anchor_t>;
   Anchors m_anchors;
 
   anchor_t m_curAnchor;
 };
-}
+}  // namespace YAML
 
 #endif  // SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66