Avoid astyle's padding in ordered_map::emplace's template headers

Use detail::conjunction instead of && and drop the redundant V&& in detail::is_constructible, so astyle keeps the usual template formatting. Addresses review comment by @gregmarr.

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

CITATION.cff

@@ -10,5 +10,5 @@ title: "JSON for Modern C++"
 version: 3.12.0
 date-released: 2025-04-07
 license: MIT
-repository-code: "https://github.com/nlohmann/json"
+repository-code: "https://github.com/nlohmann"
 url: https://json.nlohmann.me

CMakeLists.txt

@@ -42,11 +42,8 @@ endif()
 ## OPTIONS
 ##
 
-# Build the tests by default only for the main project and only if the tests
-# directory exists (the release archive json.tar.xz does not contain it).
 # VERSION_GREATER_EQUAL is not available in older CMake (< 3.7)
-if(${MAIN_PROJECT} AND (${CMAKE_VERSION} VERSION_EQUAL 3.13 OR ${CMAKE_VERSION} VERSION_GREATER 3.13)
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tests/CMakeLists.txt")
+if(${MAIN_PROJECT} AND (${CMAKE_VERSION} VERSION_EQUAL 3.13 OR ${CMAKE_VERSION} VERSION_GREATER 3.13))
     set(JSON_BuildTests_INIT ON)
 else()
     set(JSON_BuildTests_INIT OFF)

Makefile

@@ -7,9 +7,6 @@
 # find GNU sed to use `-i` parameter
 SED:=$(shell command -v gsed || which sed)
 
-# find GNU tar to use `--sort` and `--pax-option` parameters
-TAR:=$(shell command -v gtar || which tar)
-
 
 ##########################################################################
 # source files
@@ -218,8 +215,8 @@ ChangeLog.md:
 # archive is created according to the advices of <https://reproducible-builds.org/docs/archives/>.
 json.tar.xz:
 	mkdir json
-	rsync -R $(shell find LICENSE.MIT nlohmann_json.natvis CMakeLists.txt cmake/*.in include single_include src/modules -type f) json
-	$(TAR) --sort=name --mtime="@$(shell git log -1 --pretty=%ct)" --owner=0 --group=0 --numeric-owner --pax-option=exthdr.name=%d/PaxHeaders/%f,delete=atime,delete=ctime --create --file - json | xz --compress -9e --threads=2 - > json.tar.xz
+	rsync -R $(shell find LICENSE.MIT nlohmann_json.natvis CMakeLists.txt cmake/*.in include single_include -type f) json
+	gtar --sort=name --mtime="@$(shell git log -1 --pretty=%ct)" --owner=0 --group=0 --numeric-owner --pax-option=exthdr.name=%d/PaxHeaders/%f,delete=atime,delete=ctime --create --file - json | xz --compress -9e --threads=2 - > json.tar.xz
 	rm -fr json
 
 # We use `-X` to make the resulting ZIP file reproducible, see

README.md

@@ -1204,18 +1204,15 @@ language bindings, format converters, and the like. See the curated [Ecosystem](
 
 Though it's 2026 already, the support for C++11 is still a bit sparse. Currently, the following compilers are known to work:
 
-- GCC 4.8 - 16.2 (and possibly later)
-- Clang 3.4 - 22.1 (and possibly later)
-- Apple Clang 15.0 - 21.0 (and possibly later)
-- Intel C++ Compiler Classic (icpc) 2021.10
-- Intel oneAPI DPC++/C++ Compiler (icpx) 2025.3 (and possibly later)
-- NVIDIA CUDA Compiler (nvcc) 11.8 - 12.6 (and possibly later)
-- NVIDIA HPC SDK C++ Compiler (nvc++) 25.5 (and possibly later)
-- Microsoft Visual C++ 2015 / MSVC 19.0 (and possibly later)
-- Microsoft Visual C++ 2017 / MSVC 19.16 (and possibly later)
-- Microsoft Visual C++ 2019 / MSVC 19.29 (and possibly later)
-- Microsoft Visual C++ 2022 / MSVC 19.44 (and possibly later)
-- Microsoft Visual C++ 2026 / MSVC 19.51 (and possibly later)
+- GCC 4.8 - 14.2 (and possibly later)
+- Clang 3.4 - 21.0 (and possibly later)
+- Apple Clang 9.1 - 16.0 (and possibly later)
+- Intel C++ Compiler 17.0.2 (and possibly later)
+- Nvidia CUDA Compiler 11.0.221 (and possibly later)
+- Microsoft Visual C++ 2015 / Build Tools 14.0.25123.0 (and possibly later)
+- Microsoft Visual C++ 2017 / Build Tools 15.5.180.51428 (and possibly later)
+- Microsoft Visual C++ 2019 / Build Tools 16.3.1+1def00d3d (and possibly later)
+- Microsoft Visual C++ 2022 / Build Tools 19.30.30709.0 (and possibly later)
 
 I would be happy to learn about other compilers/versions.
 

docs/mkdocs/docs/api/basic_json/emplace.md

@@ -69,3 +69,5 @@ Logarithmic in the size of the container, O(log(`size()`)).
 ## Version history
 
 - Since version 2.0.8.
+- Fixed in version 3.13.0: for [`ordered_json`](../ordered_json.md), the value could previously only be passed as an
+  rvalue; it can now also be passed as an lvalue or a `#!cpp const` lvalue, matching the behavior of `json`.

docs/mkdocs/docs/integration/cmake.md

@@ -125,7 +125,7 @@ automatically download a release as a dependency at configure time.
 
 ### `JSON_BuildTests`
 
-Build the unit tests when [`BUILD_TESTING`](https://cmake.org/cmake/help/latest/command/enable_testing.html) is enabled. This option is `ON` by default if the library's CMake project is the top project and the `tests` directory exists (the release archive `json.tar.xz` does not contain it). That is, when integrating the library as described above, the test suite is not built unless explicitly switched on with this option.
+Build the unit tests when [`BUILD_TESTING`](https://cmake.org/cmake/help/latest/command/enable_testing.html) is enabled. This option is `ON` by default if the library's CMake project is the top project. That is, when integrating the library as described above, the test suite is not built unless explicitly switched on with this option.
 
 ### `JSON_CI`
 

include/nlohmann/ordered_map.hpp

@@ -70,7 +70,9 @@ template <class Key, class T, class IgnoredLess = std::less<Key>,
         return *this;
     }
 
-    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
+    template<class V, detail::enable_if_t<
+                 detail::is_constructible<T, V>::value, int> = 0>
+    std::pair<iterator, bool> emplace(const key_type& key, V && t)
     {
         for (auto it = this->begin(); it != this->end(); ++it)
         {
@@ -79,13 +81,14 @@ template <class Key, class T, class IgnoredLess = std::less<Key>,
                 return {it, false};
             }
         }
-        Container::emplace_back(key, std::forward<T>(t));
+        Container::emplace_back(key, std::forward<V>(t));
         return {std::prev(this->end()), true};
     }
 
-    template<class KeyType, detail::enable_if_t<
-                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
-    std::pair<iterator, bool> emplace(KeyType && key, T && t)
+    template<class KeyType, class V, detail::enable_if_t<
+                 detail::conjunction<detail::is_usable_as_key_type<key_compare, key_type, KeyType>,
+                                     detail::is_constructible<T, V>>::value, int> = 0>
+    std::pair<iterator, bool> emplace(KeyType && key, V && t)
     {
         for (auto it = this->begin(); it != this->end(); ++it)
         {
@@ -94,7 +97,7 @@ template <class Key, class T, class IgnoredLess = std::less<Key>,
                 return {it, false};
             }
         }
-        Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
+        Container::emplace_back(std::forward<KeyType>(key), std::forward<V>(t));
         return {std::prev(this->end()), true};
     }
 

single_include/nlohmann/json.hpp

@@ -25832,7 +25832,9 @@ template <class Key, class T, class IgnoredLess = std::less<Key>,
         return *this;
     }
 
-    std::pair<iterator, bool> emplace(const key_type& key, T&& t)
+    template<class V, detail::enable_if_t<
+                 detail::is_constructible<T, V>::value, int> = 0>
+    std::pair<iterator, bool> emplace(const key_type& key, V && t)
     {
         for (auto it = this->begin(); it != this->end(); ++it)
         {
@@ -25841,13 +25843,14 @@ template <class Key, class T, class IgnoredLess = std::less<Key>,
                 return {it, false};
             }
         }
-        Container::emplace_back(key, std::forward<T>(t));
+        Container::emplace_back(key, std::forward<V>(t));
         return {std::prev(this->end()), true};
     }
 
-    template<class KeyType, detail::enable_if_t<
-                 detail::is_usable_as_key_type<key_compare, key_type, KeyType>::value, int> = 0>
-    std::pair<iterator, bool> emplace(KeyType && key, T && t)
+    template<class KeyType, class V, detail::enable_if_t<
+                 detail::conjunction<detail::is_usable_as_key_type<key_compare, key_type, KeyType>,
+                                     detail::is_constructible<T, V>>::value, int> = 0>
+    std::pair<iterator, bool> emplace(KeyType && key, V && t)
     {
         for (auto it = this->begin(); it != this->end(); ++it)
         {
@@ -25856,7 +25859,7 @@ template <class Key, class T, class IgnoredLess = std::less<Key>,
                 return {it, false};
             }
         }
-        Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
+        Container::emplace_back(std::forward<KeyType>(key), std::forward<V>(t));
         return {std::prev(this->end()), true};
     }
 

tests/src/unit-ordered_json.cpp

@@ -196,3 +196,44 @@ TEST_CASE("regression test - diff() must account for ordered_json member order")
         CHECK(a.patch(p) == b);
     }
 }
+
+TEST_CASE("regression test for issue #5673 - ordered_json::emplace with a non-rvalue value")
+{
+    SECTION("lvalue value")
+    {
+        ordered_json oj = ordered_json::object();
+        ordered_json value = 1;
+        auto res = oj.emplace("a", value);
+        CHECK(res.second == true);
+        CHECK(oj.dump() == "{\"a\":1}");
+    }
+
+    SECTION("const lvalue value")
+    {
+        ordered_json oj = ordered_json::object();
+        const ordered_json value = 1;
+        auto res = oj.emplace("a", value);
+        CHECK(res.second == true);
+        CHECK(oj.dump() == "{\"a\":1}");
+    }
+
+    SECTION("rvalue value")
+    {
+        ordered_json oj = ordered_json::object();
+        auto res = oj.emplace("a", ordered_json(1));
+        CHECK(res.second == true);
+        CHECK(oj.dump() == "{\"a\":1}");
+    }
+
+    SECTION("existing key is not overwritten (std::map-compatible semantics)")
+    {
+        ordered_json oj = ordered_json::object();
+        ordered_json value = 1;
+        oj.emplace("a", value);
+
+        ordered_json other_value = 2;
+        auto res = oj.emplace("a", other_value);
+        CHECK(res.second == false);
+        CHECK(oj.dump() == "{\"a\":1}");
+    }
+}

tests/src/unit-ordered_map.cpp

@@ -312,4 +312,77 @@ TEST_CASE("ordered_map")
             CHECK(om.size() == 4);
         }
     }
+
+    SECTION("emplace")
+    {
+        // regression test for issue #5673: the mapped-value parameter must
+        // accept lvalues and const lvalues, not just rvalues
+        ordered_map<std::string, std::string> om;
+        om["eins"] = "one";
+        om["zwei"] = "two";
+        om["drei"] = "three";
+
+        SECTION("with T&& (rvalue)")
+        {
+            auto res1 = om.emplace("eins", std::string("1"));
+            CHECK(res1.first == om.begin());
+            CHECK(res1.second == false);
+            CHECK(om.size() == 3);
+            CHECK(om.at("eins") == "one"); // existing key is not overwritten
+
+            auto res4 = om.emplace("vier", std::string("four"));
+            CHECK(res4.first == om.begin() + 3);
+            CHECK(res4.second == true);
+            CHECK(om.size() == 4);
+            CHECK(om.at("vier") == "four");
+        }
+
+        SECTION("with T& (lvalue)")
+        {
+            std::string one = "1";
+            std::string four = "four";
+
+            auto res1 = om.emplace("eins", one);
+            CHECK(res1.first == om.begin());
+            CHECK(res1.second == false);
+            CHECK(om.size() == 3);
+            CHECK(om.at("eins") == "one"); // existing key is not overwritten
+
+            auto res4 = om.emplace("vier", four);
+            CHECK(res4.first == om.begin() + 3);
+            CHECK(res4.second == true);
+            CHECK(om.size() == 4);
+            CHECK(om.at("vier") == "four");
+            CHECK(four == "four"); // source was copied, not moved from
+        }
+
+        SECTION("with const T&")
+        {
+            const std::string one = "1";
+            const std::string four = "four";
+
+            auto res1 = om.emplace("eins", one);
+            CHECK(res1.first == om.begin());
+            CHECK(res1.second == false);
+            CHECK(om.size() == 3);
+
+            auto res4 = om.emplace("vier", four);
+            CHECK(res4.first == om.begin() + 3);
+            CHECK(res4.second == true);
+            CHECK(om.size() == 4);
+            CHECK(om.at("vier") == "four");
+        }
+
+        SECTION("with key of key_type (non-template overload)")
+        {
+            const std::string key_vier{"vier"};
+            std::string four = "four";
+
+            auto res4 = om.emplace(key_vier, four);
+            CHECK(res4.first == om.begin() + 3);
+            CHECK(res4.second == true);
+            CHECK(om.size() == 4);
+            CHECK(om.at("vier") == "four");
+        }
+    }
 }