Move throw out of include headers

add_custom_target uninstall causes a clash with the same target in rtmidi (https://github.com/thestk/rtmidi).
"add_custom_target cannot create target "uninstall" because another target with the same name already exists.  The existing target is a custom target created in source directory"

Adds new option YAML_CPP_DISABLE_UNINSTALL 

fixes #1151

---------

Co-authored-by: Megamouse <studienricky89@googlemail.de>
Co-authored-by: Jesse Beder <jbeder+github@gmail.com>

.bazelignore

@@ -0,0 +1 @@
+test/gtest-1.11.0

.github/workflows/build.yml

@@ -12,6 +12,7 @@ jobs:
         fail-fast: false
         matrix:
           os: [ubuntu-latest, windows-latest, macos-latest]
+          cxx_standard: [11, 17, 20]
           build: [static, shared]
           generator: ["Default Generator", "MinGW Makefiles"]
           exclude:
@@ -23,7 +24,6 @@ jobs:
             generator: "MinGW Makefiles"
       env:
         YAML_BUILD_SHARED_LIBS: ${{ matrix.build == 'shared' && 'ON' || 'OFF' }}
-        YAML_CPP_BUILD_TESTS: 'ON'
         CMAKE_GENERATOR: >-
           ${{format(matrix.generator != 'Default Generator' && '-G "{0}"' || '', matrix.generator)}}
       runs-on: ${{ matrix.os }}
@@ -33,16 +33,10 @@ jobs:
         - name: Get number of CPU cores
           uses: SimenB/github-actions-cpu-cores@v1
 
-        - name: Build
-          shell: bash
-          run: |
-            cmake ${{ env.CMAKE_GENERATOR }} -S "${{ github.workspace }}" -B build -DYAML_BUILD_SHARED_LIBS=${{ env.YAML_BUILD_SHARED_LIBS }}
-            cd build && cmake --build . --parallel ${{ steps.cpu-cores.outputs.count }}
-            
         - name: Build Tests
           shell: bash
           run: |
-            cmake ${{ env.CMAKE_GENERATOR }} -S "${{ github.workspace }}" -B build -DYAML_BUILD_SHARED_LIBS=${{ env.YAML_BUILD_SHARED_LIBS }} -DYAML_CPP_BUILD_TESTS=${{ env.YAML_CPP_BUILD_TESTS }}
+            cmake ${{ env.CMAKE_GENERATOR }} -S "${{ github.workspace }}" -B build -DCMAKE_CXX_STANDARD=${{ matrix.cxx_standard }} -DYAML_BUILD_SHARED_LIBS=${{ env.YAML_BUILD_SHARED_LIBS }} -DYAML_CPP_BUILD_TESTS=ON
             cd build && cmake --build . --parallel ${{ steps.cpu-cores.outputs.count }}
 
         - name: Run Tests
@@ -70,3 +64,22 @@ jobs:
             cd "${{ github.workspace }}"
             bazel test test
 
+  bzlmod-build:
+      strategy:
+        matrix:
+          os: [ubuntu-latest, windows-latest, macos-latest]
+      runs-on: ${{ matrix.os }}
+      steps:
+        - uses: actions/checkout@v2
+
+        - name: Build
+          shell: bash
+          run: |
+            cd "${{ github.workspace }}"
+            bazel build --enable_bzlmod :all
+
+        - name: Test
+          shell: bash
+          run: |
+            cd "${{ github.workspace }}"
+            bazel test --enable_bzlmod test

CMakeLists.txt

@@ -1,5 +1,6 @@
-# 3.5 is actually available almost everywhere, but this a good minimum
-cmake_minimum_required(VERSION 3.4)
+# 3.5 is actually available almost everywhere, but this a good minimum.
+# 3.14 as the upper policy limit avoids CMake deprecation warnings.
+cmake_minimum_required(VERSION 3.4...3.14)
 
 # enable MSVC_RUNTIME_LIBRARY target property
 # see https://cmake.org/cmake/help/latest/policy/CMP0091.html
@@ -24,14 +25,16 @@ option(YAML_CPP_BUILD_CONTRIB "Enable yaml-cpp contrib in library" ON)
 option(YAML_CPP_BUILD_TOOLS "Enable parse tools" ON)
 option(YAML_BUILD_SHARED_LIBS "Build yaml-cpp shared library" ${BUILD_SHARED_LIBS})
 option(YAML_CPP_INSTALL "Enable generation of yaml-cpp install targets" ${YAML_CPP_MAIN_PROJECT})
-option(YAML_CPP_FORMAT_SOURCE "Format source" ON)
+option(YAML_CPP_FORMAT_SOURCE "Format source" ${YAML_CPP_MAIN_PROJECT})
+option(YAML_CPP_DISABLE_UNINSTALL  "Disable uninstallation of yaml-cpp" OFF)
+
 cmake_dependent_option(YAML_CPP_BUILD_TESTS
   "Enable yaml-cpp tests" OFF
   "BUILD_TESTING;YAML_CPP_MAIN_PROJECT" OFF)
 cmake_dependent_option(YAML_MSVC_SHARED_RT
   "MSVC: Build yaml-cpp with shared runtime libs (/MD)" ON
   "CMAKE_SYSTEM_NAME MATCHES Windows" OFF)
- 
+
 if (YAML_CPP_FORMAT_SOURCE)
     find_program(YAML_CPP_CLANG_FORMAT_EXE NAMES clang-format)
 endif()
@@ -196,7 +199,7 @@ if (YAML_CPP_FORMAT_SOURCE AND YAML_CPP_CLANG_FORMAT_EXE)
 endif()
 
 # uninstall target
-if(NOT TARGET uninstall)
+if(YAML_CPP_INSTALL AND NOT YAML_CPP_DISABLE_UNINSTALL AND NOT TARGET uninstall)
   configure_file(
     "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
     "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"

MODULE.bazel

@@ -0,0 +1,14 @@
+"""
+yaml-cpp is a YAML parser and emitter in c++ matching the YAML specification.
+"""
+
+module(
+    name = "yaml-cpp",
+    compatibility_level = 1,
+    version = "0.8.0",
+)
+
+bazel_dep(name = "platforms", version = "0.0.7")
+bazel_dep(name = "rules_cc", version = "0.0.8")
+
+bazel_dep(name = "googletest", version = "1.14.0", dev_dependency = True)

docs/How-To-Emit-YAML.md

@@ -155,15 +155,9 @@ produces
 We overload `operator <<` for `std::vector`, `std::list`, and `std::map`, so you can write stuff like:
 
 ```cpp
-std::vector <int> squares;
-squares.push_back(1);
-squares.push_back(4);
-squares.push_back(9);
-squares.push_back(16);
+std::vector <int> squares = {1, 4, 9, 16};
 
-std::map <std::string, int> ages;
-ages["Daniel"] = 26;
-ages["Jesse"] = 24;
+std::map <std::string, int> ages = {{"Daniel", 26}, {"Jesse", 24}};
 
 YAML::Emitter out;
 out << YAML::BeginSeq;
@@ -227,4 +221,4 @@ assert(out.good());
 out << YAML::Key;
 assert(!out.good());
 std::cout << "Emitter error: " << out.GetLastError() << "\n";
-```
+```

include/yaml-cpp/node/convert.h

@@ -18,7 +18,7 @@
 #include <valarray>
 #include <vector>
 
-#if __cplusplus >= 201703L
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
 #include <string_view>
 #endif
 
@@ -93,7 +93,7 @@ struct convert<char[N]> {
   static Node encode(const char* rhs) { return Node(rhs); }
 };
 
-#if __cplusplus >= 201703L
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
 template <>
 struct convert<std::string_view> {
   static Node encode(std::string_view rhs) { return Node(std::string(rhs)); }

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

@@ -14,6 +14,7 @@
 #include <type_traits>
 
 namespace YAML {
+[[noreturn]] void throw_bad_subscript(const YAML::Mark& mark);
 namespace detail {
 template <typename Key, typename Enable = void>
 struct get_idx {
@@ -128,7 +129,7 @@ inline node* node_data::get(const Key& key,
         return pNode;
       return nullptr;
     case NodeType::Scalar:
-      throw BadSubscript(m_mark, key);
+      throw_bad_subscript(m_mark);
   }
 
   auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
@@ -154,7 +155,7 @@ inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
       convert_to_map(pMemory);
       break;
     case NodeType::Scalar:
-      throw BadSubscript(m_mark, key);
+      throw_bad_subscript(m_mark);
   }
 
   auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
@@ -200,6 +201,8 @@ inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) {
   return false;
 }
 
+[[nodiscard]] void throw_bad_insert();
+
 // map
 template <typename Key, typename Value>
 inline void node_data::force_insert(const Key& key, const Value& value,
@@ -213,7 +216,7 @@ inline void node_data::force_insert(const Key& key, const Value& value,
       convert_to_map(pMemory);
       break;
     case NodeType::Scalar:
-      throw BadInsert();
+      throw_bad_insert();
   }
 
   node& k = convert_to_node(key, pMemory);

include/yaml-cpp/node/impl.h

@@ -16,6 +16,8 @@
 #include <string>
 
 namespace YAML {
+[[noreturn]] extern void throw_invalid_node(const std::string& key);
+[[noreturn]] extern void throw_bad_conversion(const YAML::Mark& mark);
 inline Node::Node()
     : m_isValid(true), m_invalidKey{}, m_pMemory(nullptr), m_pNode(nullptr) {}
 
@@ -57,7 +59,7 @@ inline Node::~Node() = default;
 
 inline void Node::EnsureNodeExists() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   if (!m_pNode) {
     m_pMemory.reset(new detail::memory_holder);
     m_pNode = &m_pMemory->create_node();
@@ -74,14 +76,14 @@ inline bool Node::IsDefined() const {
 
 inline Mark Node::Mark() const {
   if (!m_isValid) {
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   }
   return m_pNode ? m_pNode->mark() : Mark::null_mark();
 }
 
 inline NodeType::value Node::Type() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   return m_pNode ? m_pNode->type() : NodeType::Null;
 }
 
@@ -125,12 +127,12 @@ struct as_if<T, void> {
 
   T operator()() const {
     if (!node.m_pNode)
-      throw TypedBadConversion<T>(node.Mark());
+      throw_bad_conversion(node.Mark()); // <T>
 
     T t;
     if (convert<T>::decode(node, t))
       return t;
-    throw TypedBadConversion<T>(node.Mark());
+    throw_bad_conversion(node.Mark()); // <T>
   }
 };
 
@@ -143,7 +145,7 @@ struct as_if<std::string, void> {
     if (node.Type() == NodeType::Null)
       return "null";
     if (node.Type() != NodeType::Scalar)
-      throw TypedBadConversion<std::string>(node.Mark());
+      throw_bad_conversion(node.Mark()); // <std::string>
     return node.Scalar();
   }
 };
@@ -152,7 +154,7 @@ struct as_if<std::string, void> {
 template <typename T>
 inline T Node::as() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   return as_if<T, void>(*this)();
 }
 
@@ -165,13 +167,13 @@ inline T Node::as(const S& fallback) const {
 
 inline const std::string& Node::Scalar() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar();
 }
 
 inline const std::string& Node::Tag() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar();
 }
 
@@ -182,7 +184,7 @@ inline void Node::SetTag(const std::string& tag) {
 
 inline EmitterStyle::value Node::Style() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   return m_pNode ? m_pNode->style() : EmitterStyle::Default;
 }
 
@@ -194,7 +196,7 @@ inline void Node::SetStyle(EmitterStyle::value style) {
 // assignment
 inline bool Node::is(const Node& rhs) const {
   if (!m_isValid || !rhs.m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   if (!m_pNode || !rhs.m_pNode)
     return false;
   return m_pNode->is(*rhs.m_pNode);
@@ -215,7 +217,7 @@ inline Node& Node::operator=(const Node& rhs) {
 
 inline void Node::reset(const YAML::Node& rhs) {
   if (!m_isValid || !rhs.m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   m_pMemory = rhs.m_pMemory;
   m_pNode = rhs.m_pNode;
 }
@@ -223,7 +225,7 @@ inline void Node::reset(const YAML::Node& rhs) {
 template <typename T>
 inline void Node::Assign(const T& rhs) {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   AssignData(convert<T>::encode(rhs));
 }
 
@@ -253,7 +255,7 @@ inline void Node::AssignData(const Node& rhs) {
 
 inline void Node::AssignNode(const Node& rhs) {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   rhs.EnsureNodeExists();
 
   if (!m_pNode) {
@@ -270,7 +272,7 @@ inline void Node::AssignNode(const Node& rhs) {
 // size/iterator
 inline std::size_t Node::size() const {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   return m_pNode ? m_pNode->size() : 0;
 }
 
@@ -303,7 +305,7 @@ inline iterator Node::end() {
 template <typename T>
 inline void Node::push_back(const T& rhs) {
   if (!m_isValid)
-    throw InvalidNode(m_invalidKey);
+    throw_invalid_node(m_invalidKey);
   push_back(Node(rhs));
 }
 

src/exceptions.cpp

@@ -17,4 +17,24 @@ BadPushback::~BadPushback() YAML_CPP_NOEXCEPT = default;
 BadInsert::~BadInsert() YAML_CPP_NOEXCEPT = default;
 EmitterException::~EmitterException() YAML_CPP_NOEXCEPT = default;
 BadFile::~BadFile() YAML_CPP_NOEXCEPT = default;
+
+[[noreturn]] void throw_bad_subscript(const YAML::Mark& mark)
+{
+	throw BadSubscript(mark, std::string{});
+}
+
+[[noreturn]] void throw_invalid_node(const std::string& key)
+{
+	throw InvalidNode(key);
+}
+
+[[noreturn]] void throw_bad_conversion(const YAML::Mark& mark)
+{
+	throw BadConversion(mark);
+}
+
+[[noreturn]] void throw_bad_insert()
+{
+	throw BadInsert();
+}
 }  // namespace YAML

test/CMakeLists.txt

@@ -33,7 +33,7 @@ target_include_directories(yaml-cpp-tests
 target_compile_options(yaml-cpp-tests
   PRIVATE
     $<$<CXX_COMPILER_ID:Clang>:-Wno-c99-extensions -Wno-variadic-macros -Wno-sign-compare>
-    $<$<CXX_COMPILER_ID:GNU>:-Wno-variadic-macros -Wno-sign-compare>)
+    $<$<CXX_COMPILER_ID:GNU>:-Wno-variadic-macros -Wno-sign-compare -Wno-narrowing>)
 target_link_libraries(yaml-cpp-tests
   PRIVATE
     Threads::Threads