Rewrite the float-to-string conversion

Instead of committing to a number of decimal places, the new algorithm targets a certain number of significant digits.
Since the mantissa has to fit in a 32-bit integer, the number of significant digits is limited to 9.

.github/workflows/ci.yml

@@ -93,44 +93,40 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - clang: "3.9"
-            runner: ubuntu-20.04
-            archive: bionic
-          - clang: "4.0"
-            runner: ubuntu-20.04
-            archive: bionic
-          - clang: "5.0"
-            runner: ubuntu-20.04
-            archive: bionic
-          - clang: "6.0"
-            runner: ubuntu-20.04
-            archive: bionic
           - clang: "7"
-            runner: ubuntu-20.04
+            runner: ubuntu-22.04
+            archive: focal
           - clang: "8"
             cxxflags: -fsanitize=leak -fno-sanitize-recover=all
-            runner: ubuntu-20.04
+            runner: ubuntu-22.04
+            archive: focal
           - clang: "9"
             cxxflags: -fsanitize=undefined -fno-sanitize-recover=all
-            runner: ubuntu-20.04
+            runner: ubuntu-22.04
+            archive: focal
           - clang: "10"
             cxxflags: -fsanitize=address -fno-sanitize-recover=all
-            runner: ubuntu-20.04
+            runner: ubuntu-22.04
+            archive: focal
           - clang: "11"
             runner: ubuntu-22.04
           - clang: "12"
             runner: ubuntu-22.04
           - clang: "13"
             runner: ubuntu-22.04
-          - clang: "14"
-            runner: ubuntu-22.04
-          - clang: "15"
-            runner: ubuntu-22.04
-    runs-on: ${{ matrix.runner }}
+          - clang: 14
+          - clang: 15
+          - clang: 16
+          - clang: 17
+          - clang: 18
+          - clang: 19
+    runs-on: ${{ matrix.runner || 'ubuntu-latest' }}
     steps:
       - name: Add archive repositories
         if: matrix.archive
         run: |
+          sudo gpg --keyserver keyserver.ubuntu.com --recv-keys 3B4FE6ACC0B21F32
+          sudo gpg --export 3B4FE6ACC0B21F32 | sudo tee /etc/apt/trusted.gpg.d/ubuntu-keyring.gpg > /dev/null
           sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ ${{ matrix.archive }} main'
           sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ ${{ matrix.archive }} universe'
       - name: Install Clang ${{ matrix.clang }}
@@ -138,10 +134,9 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y clang-${{ matrix.clang }}
       - name: Install libc++ ${{ matrix.clang }}
-        if: matrix.clang >= 11
         run: sudo apt-get install -y libc++-${{ matrix.clang }}-dev libc++abi-${{ matrix.clang }}-dev
       - name: Install libunwind ${{ matrix.clang }}
-        if: matrix.clang == 12  # dependency is missing in Ubuntu 22.04
+        if: matrix.clang == 12 # dependency is missing in Ubuntu 22.04
         run: sudo apt-get install -y libunwind-${{ matrix.clang }}-dev
       - name: Checkout
         uses: actions/checkout@v4
@@ -163,7 +158,7 @@ jobs:
   conf_test:
     name: Test configuration on Linux
     needs: [gcc, clang]
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
       - name: Install
         run: |
@@ -184,19 +179,19 @@ jobs:
 
   conf_test_windows:
     name: Test configuration on Windows
-    runs-on: windows-2019
+    runs-on: windows-2022
     needs: [gcc, clang]
     steps:
       - name: Checkout
         uses: actions/checkout@v4
       - name: 32-bit
         run: |
-          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars32.bat"
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars32.bat"
           cl /Isrc extras/conf_test/x86.cpp
         shell: cmd
       - name: 64-bit
         run: |
-          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           cl /Isrc extras/conf_test/x64.cpp
         shell: cmd
 
@@ -257,7 +252,7 @@ jobs:
             board: arduino:avr:uno
           - core: arduino:samd
             board: arduino:samd:mkr1000
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -403,7 +398,9 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Install Particle CLI
-        run: sudo npm install -g particle-cli
+        run: |
+          bash <( curl -sL https://particle.io/install-cli )
+          echo "$HOME/bin" >> $GITHUB_PATH
       - name: Login to Particle
         run: particle login -t "${{ secrets.PARTICLE_TOKEN }}"
       - name: Compile
@@ -412,7 +409,7 @@ jobs:
   arm:
     name: GCC for ARM processor
     needs: gcc
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
       - name: Install
         run: |
@@ -431,7 +428,7 @@ jobs:
   coverage:
     needs: gcc
     name: Coverage
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
       - name: Install
         run: sudo apt-get install -y lcov ninja-build
@@ -463,7 +460,7 @@ jobs:
   valgrind:
     needs: gcc
     name: Valgrind
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
       - name: Install
         run: |
@@ -485,24 +482,24 @@ jobs:
   clang-tidy:
     needs: clang
     name: Clang-Tidy
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - name: Install
-        run: sudo apt-get install -y clang-tidy cmake ninja-build
+        run: sudo apt-get install -y clang-tidy libc++-dev libc++abi-dev
       - name: Checkout
         uses: actions/checkout@v4
       - name: Configure
-        run: cmake -G Ninja -DCMAKE_CXX_CLANG_TIDY="clang-tidy-10;--warnings-as-errors=*" -DCMAKE_BUILD_TYPE=Debug .
+        run: cmake -G Ninja -DCMAKE_CXX_CLANG_TIDY="clang-tidy;--warnings-as-errors=*" -DCMAKE_BUILD_TYPE=Debug .
         env:
-          CC: clang-10
-          CXX: clang++-10
+          CC: clang
+          CXX: clang++
       - name: Check
         run: cmake --build . -- -k 0
 
   amalgamate:
     needs: gcc
     name: Amalgamate ArduinoJson.h
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -578,7 +575,7 @@ jobs:
 
   codeql:
     name: CodeQL
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     needs: gcc
 
     permissions:
@@ -587,20 +584,20 @@ jobs:
       security-events: write
 
     steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
+      - name: Checkout repository
+        uses: actions/checkout@v4
 
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
-      with:
-        languages: cpp
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v3
+        with:
+          languages: cpp
 
-    - name: Build
-      run: |
-        cmake -DCMAKE_BUILD_TYPE=Debug .
-        cmake --build .
+      - name: Build
+        run: |
+          cmake -DCMAKE_BUILD_TYPE=Debug .
+          cmake --build .
 
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
-      with:
-        category: "/language:cpp"
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v3
+        with:
+          category: "/language:cpp"

.github/workflows/release.yml

@@ -8,7 +8,7 @@ on:
 jobs:
   release:
     name: Create release
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
       - name: Set variables
         id: init

CHANGELOG.md

@@ -1,6 +1,45 @@
 ArduinoJson: change log
 =======================
 
+HEAD
+----
+
+* Don't store string literals by pointer anymore (issue #2189)
+  Version 7.3 introduced a new way to detect string literals, but it fails in some edge cases.
+  I could not find a way to fix it, so I chose to remove the optimization rather than keep it broken.
+* Replace the "extension slots" mechanism with a memory pool dedicated to 8-byte values.
+
+> ### BREAKING CHANGES
+>
+> #### `JsonString` constructor's boolean parameter
+>
+> Since version 7.3, you could pass a boolean to `JsonString`'s constructor to force the string to be stored by pointer.
+> This optimization has been removed, and you'll get a deprecation warning if you use it.
+> To fix the issue, you must remove the boolean argument from the constructor, or better yet, remove `JsonString` altogether.
+>
+> ```diff
+>   char name[] = "ArduinoJson";
+> - doc["name"] = JsonString(name, true);
+> + doc["name"] = name;
+> ```
+>
+> #### NUL characters in string literals
+> 
+> Since version 7.3, ArduinoJson has supported NUL characters (`\0`) in string literals.
+> This feature has been removed as part of the storage policy change.
+>
+> If you do need to include NULs in your string, you must use a `JsonString` instead:
+>
+> ```diff
+> - doc["strings"] = "hello\0world"
+> + doc["strings"] = JsonString("hello\0world", 11)
+> ```
+
+v7.4.2 (2025-06-20)
+------
+
+* Fix truncated strings on Arduino Due (issue #2181)
+
 v7.4.1 (2025-04-11)
 ------
 

CMakeLists.txt

@@ -10,7 +10,7 @@ if(ESP_PLATFORM)
 	return()
 endif()
 
-project(ArduinoJson VERSION 7.4.1)
+project(ArduinoJson VERSION 7.4.2)
 
 if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
 	include(CTest)

README.md

@@ -80,7 +80,7 @@ ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).
     * Continuously tested on
         * [Visual Studio 2017, 2019, 2022](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/7.x)
         * [GCC 4.8, 5, 6, 7, 8, 9, 10, 11, 12](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22)
-        * [Clang 3.9, 4.0, 5.0, 6.0, 7, 8, 9, 10, 11, 12, 13, 14, 15](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22)
+        * [Clang 7 to 19](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22)
     * [Continuously fuzzed with Google OSS Fuzz](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:arduinojson)
     * Passes all default checks of [clang-tidy](https://releases.llvm.org/10.0.0/tools/clang/tools/extra/docs/clang-tidy/)
 * Well documented
@@ -139,11 +139,6 @@ See the [tutorial on arduinojson.org](https://arduinojson.org/v7/doc/serializati
 
 ArduinoJson is thankful to its sponsors. Please give them a visit; they deserve it!
 
-<p>
-  <a href="https://www.programmingelectronics.com/" rel="sponsored">
-    <img src="https://arduinojson.org/images/2021/10/programmingeleactronicsacademy.png" alt="Programming Electronics Academy" width="200">
-  </a>
-</p>
 <p>
   <a href="https://github.com/1technophile" rel="sponsored">
     <img alt="1technophile" src="https://avatars.githubusercontent.com/u/12672732?s=40&v=4">

appveyor.yml

@@ -1,4 +1,4 @@
-version: 7.4.1.{build}
+version: 7.4.2.{build}
 environment:
   matrix:
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022

extras/conf_test/avr.cpp

@@ -12,7 +12,7 @@ static_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, "ARDUINOJSON_LITTLE_ENDIAN");
 
 static_assert(ARDUINOJSON_USE_DOUBLE == 0, "ARDUINOJSON_USE_DOUBLE");
 
-static_assert(ArduinoJson::detail::ResourceManager::slotSize == 6, "slot size");
+static_assert(sizeof(ArduinoJson::detail::VariantData) == 6, "slot size");
 
 void setup() {}
 void loop() {}

extras/conf_test/esp8266.cpp

@@ -10,7 +10,7 @@ static_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, "ARDUINOJSON_LITTLE_ENDIAN");
 
 static_assert(ARDUINOJSON_USE_DOUBLE == 1, "ARDUINOJSON_USE_DOUBLE");
 
-static_assert(ArduinoJson::detail::ResourceManager::slotSize == 8, "slot size");
+static_assert(sizeof(ArduinoJson::detail::VariantData) == 8, "slot size");
 
 void setup() {}
 void loop() {}

extras/conf_test/x64.cpp

@@ -10,7 +10,6 @@ static_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, "ARDUINOJSON_LITTLE_ENDIAN");
 
 static_assert(ARDUINOJSON_USE_DOUBLE == 1, "ARDUINOJSON_USE_DOUBLE");
 
-static_assert(ArduinoJson::detail::ResourceManager::slotSize == 16,
-              "slot size");
+static_assert(sizeof(ArduinoJson::detail::VariantData) == 16, "slot size");
 
 int main() {}

extras/conf_test/x86.cpp

@@ -10,6 +10,6 @@ static_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, "ARDUINOJSON_LITTLE_ENDIAN");
 
 static_assert(ARDUINOJSON_USE_DOUBLE == 1, "ARDUINOJSON_USE_DOUBLE");
 
-static_assert(ArduinoJson::detail::ResourceManager::slotSize == 8, "slot size");
+static_assert(sizeof(ArduinoJson::detail::VariantData) == 8, "slot size");
 
 int main() {}

extras/tests/Deprecated/BasicJsonDocument.cpp

@@ -54,7 +54,7 @@ TEST_CASE("BasicJsonDocument") {
     doc["hello"] = "world";
     auto copy = doc;
     REQUIRE(copy.as<std::string>() == "{\"hello\":\"world\"}");
-    REQUIRE(allocatorLog == "AA");
+    REQUIRE(allocatorLog == "AAAAAA");
   }
 
   SECTION("capacity") {

extras/tests/Helpers/Allocators.hpp

@@ -269,10 +269,10 @@ inline size_t sizeofPoolList(size_t n = ARDUINOJSON_INITIAL_POOL_COUNT) {
   return sizeof(MemoryPool<VariantData>) * n;
 }
 
+template <typename T = ArduinoJson::detail::VariantData>
 inline size_t sizeofPool(
     ArduinoJson::detail::SlotCount n = ARDUINOJSON_POOL_CAPACITY) {
-  using namespace ArduinoJson::detail;
-  return MemoryPool<VariantData>::slotsToBytes(n);
+  return ArduinoJson::detail::MemoryPool<T>::slotsToBytes(n);
 }
 
 inline size_t sizeofStringBuffer(size_t iteration = 1) {

extras/tests/JsonArray/add.cpp

@@ -8,7 +8,7 @@
 #include "Allocators.hpp"
 #include "Literals.hpp"
 
-using ArduinoJson::detail::sizeofArray;
+using namespace ArduinoJson::detail;
 
 TEST_CASE("JsonArray::add(T)") {
   SpyingAllocator spy;
@@ -33,7 +33,8 @@ TEST_CASE("JsonArray::add(T)") {
     REQUIRE(array[0].is<double>());
     REQUIRE_FALSE(array[0].is<bool>());
     REQUIRE(spy.log() == AllocatorLog{
-                             Allocate(sizeofPool()),
+                             Allocate(sizeofPool<VariantData>()),
+                             Allocate(sizeofPool<EightByteValue>()),
                          });
   }
 
@@ -56,6 +57,7 @@ TEST_CASE("JsonArray::add(T)") {
     REQUIRE(array[0].is<int>() == false);
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
+                             Allocate(sizeofString("hello")),
                          });
   }
 

extras/tests/JsonDeserializer/array.cpp

@@ -7,7 +7,7 @@
 
 #include "Allocators.hpp"
 
-using ArduinoJson::detail::sizeofArray;
+using namespace ArduinoJson::detail;
 
 TEST_CASE("deserialize JSON array") {
   SpyingAllocator spy;
@@ -92,8 +92,12 @@ TEST_CASE("deserialize JSON array") {
       REQUIRE(arr[0].as<double>() == Approx(4.2123456));
       REQUIRE(arr[1] == -7E89);
       REQUIRE(spy.log() == AllocatorLog{
-                               Allocate(sizeofPool()),
-                               Reallocate(sizeofPool(), sizeofPool(4)),
+                               Allocate(sizeofPool<VariantData>()),
+                               Allocate(sizeofPool<EightByteValue>()),
+                               Reallocate(sizeofPool<VariantData>(),
+                                          sizeofPool<VariantData>(2)),
+                               Reallocate(sizeofPool<EightByteValue>(),
+                                          sizeofPool<EightByteValue>(2)),
                            });
     }
 

extras/tests/JsonDeserializer/destination_types.cpp

@@ -104,6 +104,8 @@ TEST_CASE("deserializeJson(MemberProxy)") {
 
     REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.as<std::string>() == "{\"hello\":\"world\",\"value\":[42]}");
-    REQUIRE(spy.log() == AllocatorLog{});
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofString("value")),
+                         });
   }
 }

extras/tests/JsonDeserializer/errors.cpp

@@ -121,7 +121,7 @@ TEST_CASE("deserializeJson() returns NoMemory if string length overflows") {
   }
 }
 
-TEST_CASE("deserializeJson() returns NoMemory if extension allocation fails") {
+TEST_CASE("deserializeJson() returns NoMemory if 8-bit slot allocation fails") {
   JsonDocument doc(FailingAllocator::instance());
 
   SECTION("uint32_t should pass") {

extras/tests/JsonDocument/ElementProxy.cpp

@@ -31,6 +31,7 @@ TEST_CASE("ElementProxy::add()") {
     REQUIRE(doc.as<std::string>() == "[[\"world\"]]");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
+                             Allocate(sizeofString("world")),
                          });
   }
 

extras/tests/JsonDocument/MemberProxy.cpp

@@ -25,6 +25,7 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[42]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
+                             Allocate(sizeofString("hello")),
                          });
   }
 
@@ -34,6 +35,8 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[\"world\"]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
+                             Allocate(sizeofString("hello")),
+                             Allocate(sizeofString("world")),
                          });
   }
 
@@ -44,6 +47,7 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[\"world\"]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
+                             Allocate(sizeofString("hello")),
                              Allocate(sizeofString("world")),
                          });
   }
@@ -55,6 +59,7 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[\"world\"]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
+                             Allocate(sizeofString("hello")),
                              Allocate(sizeofString("world")),
 
                          });
@@ -71,6 +76,7 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[\"world\"]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
+                             Allocate(sizeofString("hello")),
                              Allocate(sizeofString("world")),
                          });
   }

extras/tests/JsonDocument/add.cpp

@@ -32,6 +32,7 @@ TEST_CASE("JsonDocument::add(T)") {
     REQUIRE(doc.as<std::string>() == "[\"hello\"]");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
+                             Allocate(sizeofString("hello")),
                          });
   }
 

extras/tests/JsonDocument/assignment.cpp

@@ -69,6 +69,8 @@ TEST_CASE("JsonDocument assignment") {
       doc2 = std::move(doc1);
 
       REQUIRE(doc2.as<std::string>() == "{\"hello\":\"world\"}");
+
+      // NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)
       REQUIRE(doc1.as<std::string>() == "null");
     }
     REQUIRE(spyingAllocator.log() == AllocatorLog{

extras/tests/JsonDocument/constructor.cpp

@@ -8,8 +8,6 @@
 #include "Allocators.hpp"
 #include "Literals.hpp"
 
-using ArduinoJson::detail::addPadding;
-
 TEST_CASE("JsonDocument constructor") {
   SpyingAllocator spyingAllocator;
 
@@ -44,6 +42,8 @@ TEST_CASE("JsonDocument constructor") {
       JsonDocument doc2(std::move(doc1));
 
       REQUIRE(doc2.as<std::string>() == "The size of this string is 32!!");
+
+      // NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)
       REQUIRE(doc1.as<std::string>() == "null");
     }
     REQUIRE(spyingAllocator.log() == AllocatorLog{
@@ -62,6 +62,8 @@ TEST_CASE("JsonDocument constructor") {
     REQUIRE(doc2.as<std::string>() == "{\"hello\":\"world\"}");
     REQUIRE(spyingAllocator.log() == AllocatorLog{
                                          Allocate(sizeofPool()),
+                                         Allocate(sizeofString("hello")),
+                                         Allocate(sizeofString("world")),
                                      });
   }
 
@@ -85,6 +87,7 @@ TEST_CASE("JsonDocument constructor") {
     REQUIRE(doc2.as<std::string>() == "[\"hello\"]");
     REQUIRE(spyingAllocator.log() == AllocatorLog{
                                          Allocate(sizeofPool()),
+                                         Allocate(sizeofString("hello")),
                                      });
   }
 

extras/tests/JsonDocument/remove.cpp

@@ -22,10 +22,10 @@ TEST_CASE("JsonDocument::remove()") {
 
   SECTION("string literal") {
     doc["a"] = 1;
-    doc["a\0b"_s] = 2;
+    doc["ab"_s] = 2;
     doc["b"] = 3;
 
-    doc.remove("a\0b");
+    doc.remove("ab");
 
     REQUIRE(doc.as<std::string>() == "{\"a\":1,\"b\":3}");
   }

extras/tests/JsonDocument/set.cpp

@@ -37,7 +37,9 @@ TEST_CASE("JsonDocument::set()") {
     doc.set("example");
 
     REQUIRE(doc.as<const char*>() == "example"_s);
-    REQUIRE(spy.log() == AllocatorLog{});
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofString("example")),
+                         });
   }
 
   SECTION("const char*") {

extras/tests/JsonDocument/shrinkToFit.cpp

@@ -69,17 +69,8 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
     REQUIRE(spyingAllocator.log() == AllocatorLog{});
   }
 
-  SECTION("linked string") {
-    doc.set("hello");
-
-    doc.shrinkToFit();
-
-    REQUIRE(doc.as<std::string>() == "hello");
-    REQUIRE(spyingAllocator.log() == AllocatorLog{});
-  }
-
-  SECTION("owned string") {
-    doc.set("abcdefg"_s);
+  SECTION("string") {
+    doc.set("abcdefg");
     REQUIRE(doc.as<std::string>() == "abcdefg");
 
     doc.shrinkToFit();
@@ -101,20 +92,7 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
                                      });
   }
 
-  SECTION("linked key") {
-    doc["key"] = 42;
-
-    doc.shrinkToFit();
-
-    REQUIRE(doc.as<std::string>() == "{\"key\":42}");
-    REQUIRE(spyingAllocator.log() ==
-            AllocatorLog{
-                Allocate(sizeofPool()),
-                Reallocate(sizeofPool(), sizeofObject(1)),
-            });
-  }
-
-  SECTION("owned key") {
+  SECTION("object key") {
     doc["abcdefg"_s] = 42;
 
     doc.shrinkToFit();
@@ -128,20 +106,7 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
             });
   }
 
-  SECTION("linked string in array") {
-    doc.add("hello");
-
-    doc.shrinkToFit();
-
-    REQUIRE(doc.as<std::string>() == "[\"hello\"]");
-    REQUIRE(spyingAllocator.log() ==
-            AllocatorLog{
-                Allocate(sizeofPool()),
-                Reallocate(sizeofPool(), sizeofArray(1)),
-            });
-  }
-
-  SECTION("owned string in array") {
+  SECTION("string in array") {
     doc.add("abcdefg"_s);
 
     doc.shrinkToFit();
@@ -155,20 +120,7 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
             });
   }
 
-  SECTION("linked string in object") {
-    doc["key"] = "hello";
-
-    doc.shrinkToFit();
-
-    REQUIRE(doc.as<std::string>() == "{\"key\":\"hello\"}");
-    REQUIRE(spyingAllocator.log() ==
-            AllocatorLog{
-                Allocate(sizeofPool()),
-                Reallocate(sizeofPool(), sizeofObject(1)),
-            });
-  }
-
-  SECTION("owned string in object") {
+  SECTION("string in object") {
     doc["key"] = "abcdefg"_s;
 
     doc.shrinkToFit();

extras/tests/JsonDocument/subscript.cpp

@@ -14,7 +14,7 @@ TEST_CASE("JsonDocument::operator[]") {
 
   SECTION("object") {
     doc["abc"_s] = "ABC";
-    doc["abc\0d"_s] = "ABCD";
+    doc["abcd"_s] = "ABCD";
 
     SECTION("const char*") {
       const char* key = "abc";
@@ -25,20 +25,20 @@ TEST_CASE("JsonDocument::operator[]") {
     SECTION("string literal") {
       REQUIRE(doc["abc"] == "ABC");
       REQUIRE(cdoc["abc"] == "ABC");
-      REQUIRE(doc["abc\0d"] == "ABCD");
-      REQUIRE(cdoc["abc\0d"] == "ABCD");
+      REQUIRE(doc["abcd"] == "ABCD");
+      REQUIRE(cdoc["abcd"] == "ABCD");
     }
 
     SECTION("std::string") {
       REQUIRE(doc["abc"_s] == "ABC");
       REQUIRE(cdoc["abc"_s] == "ABC");
-      REQUIRE(doc["abc\0d"_s] == "ABCD");
-      REQUIRE(cdoc["abc\0d"_s] == "ABCD");
+      REQUIRE(doc["abcd"_s] == "ABCD");
+      REQUIRE(cdoc["abcd"_s] == "ABCD");
     }
 
     SECTION("JsonVariant") {
       doc["key1"] = "abc";
-      doc["key2"] = "abc\0d"_s;
+      doc["key2"] = "abcd"_s;
       doc["key3"] = "foo";
 
       CHECK(doc[doc["key1"]] == "ABC");
@@ -114,6 +114,7 @@ TEST_CASE("JsonDocument::operator[] key storage") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":0}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
+                             Allocate(sizeofString("hello")),
                          });
   }
 

extras/tests/JsonObject/set.cpp

@@ -16,44 +16,18 @@ TEST_CASE("JsonObject::set()") {
   JsonObject obj1 = doc1.to<JsonObject>();
   JsonObject obj2 = doc2.to<JsonObject>();
 
-  SECTION("doesn't copy static string in key or value") {
+  SECTION("copy key and string value") {
     obj1["hello"] = "world";
     spy.clearLog();
 
     bool success = obj2.set(obj1);
 
-    REQUIRE(success == true);
-    REQUIRE(obj2["hello"] == "world"_s);
-    REQUIRE(spy.log() == AllocatorLog{
-                             Allocate(sizeofPool()),
-                         });
-  }
-
-  SECTION("copy local string value") {
-    obj1["hello"] = "world"_s;
-    spy.clearLog();
-
-    bool success = obj2.set(obj1);
-
-    REQUIRE(success == true);
-    REQUIRE(obj2["hello"] == "world"_s);
-    REQUIRE(spy.log() == AllocatorLog{
-                             Allocate(sizeofPool()),
-                             Allocate(sizeofString("world")),
-                         });
-  }
-
-  SECTION("copy local key") {
-    obj1["hello"_s] = "world";
-    spy.clearLog();
-
-    bool success = obj2.set(obj1);
-
     REQUIRE(success == true);
     REQUIRE(obj2["hello"] == "world"_s);
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
                              Allocate(sizeofString("hello")),
+                             Allocate(sizeofString("world")),
                          });
   }
 
@@ -110,7 +84,7 @@ TEST_CASE("JsonObject::set()") {
   }
 
   SECTION("copy fails in the middle of an array") {
-    TimebombAllocator timebomb(1);
+    TimebombAllocator timebomb(2);
     JsonDocument doc3(&timebomb);
     JsonObject obj3 = doc3.to<JsonObject>();
 

extras/tests/JsonObject/subscript.cpp

@@ -101,30 +101,8 @@ TEST_CASE("JsonObject::operator[]") {
     obj[key] = 42;
     REQUIRE(42 == obj[key]);
   }
-
-  SECTION("should not duplicate const char*") {
+  SECTION("should duplicate key and value strings") {
     obj["hello"] = "world";
-    REQUIRE(spy.log() == AllocatorLog{Allocate(sizeofPool())});
-  }
-
-  SECTION("should duplicate char* value") {
-    obj["hello"] = const_cast<char*>("world");
-    REQUIRE(spy.log() == AllocatorLog{
-                             Allocate(sizeofPool()),
-                             Allocate(sizeofString("world")),
-                         });
-  }
-
-  SECTION("should duplicate char* key") {
-    obj[const_cast<char*>("hello")] = "world";
-    REQUIRE(spy.log() == AllocatorLog{
-                             Allocate(sizeofPool()),
-                             Allocate(sizeofString("hello")),
-                         });
-  }
-
-  SECTION("should duplicate char* key&value") {
-    obj[const_cast<char*>("hello")] = const_cast<char*>("world");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
                              Allocate(sizeofString("hello")),
@@ -132,46 +110,6 @@ TEST_CASE("JsonObject::operator[]") {
                          });
   }
 
-  SECTION("should duplicate std::string value") {
-    obj["hello"] = "world"_s;
-    REQUIRE(spy.log() == AllocatorLog{
-                             Allocate(sizeofPool()),
-                             Allocate(sizeofString("world")),
-                         });
-  }
-
-  SECTION("should duplicate std::string key") {
-    obj["hello"_s] = "world";
-    REQUIRE(spy.log() == AllocatorLog{
-                             Allocate(sizeofPool()),
-                             Allocate(sizeofString("hello")),
-                         });
-  }
-
-  SECTION("should duplicate std::string key&value") {
-    obj["hello"_s] = "world"_s;
-    REQUIRE(spy.log() == AllocatorLog{
-                             Allocate(sizeofPool()),
-                             Allocate(sizeofString("hello")),
-                             Allocate(sizeofString("world")),
-                         });
-  }
-
-  SECTION("should duplicate a non-static JsonString key") {
-    obj[JsonString("hello", false)] = "world";
-    REQUIRE(spy.log() == AllocatorLog{
-                             Allocate(sizeofPool()),
-                             Allocate(sizeofString("hello")),
-                         });
-  }
-
-  SECTION("should not duplicate a static JsonString key") {
-    obj[JsonString("hello", true)] = "world";
-    REQUIRE(spy.log() == AllocatorLog{
-                             Allocate(sizeofPool()),
-                         });
-  }
-
   SECTION("should ignore null key") {
     // object must have a value to make a call to strcmp()
     obj["dummy"] = 42;

extras/tests/JsonSerializer/JsonVariant.cpp

@@ -9,124 +9,90 @@
 #include "Literals.hpp"
 
 template <typename T>
-void check(T value, const std::string& expected) {
+std::string serialize(T value) {
   JsonDocument doc;
   doc.to<JsonVariant>().set(value);
-  char buffer[256] = "";
-  size_t returnValue = serializeJson(doc, buffer, sizeof(buffer));
-  REQUIRE(expected == buffer);
-  REQUIRE(expected.size() == returnValue);
+  std::string output;
+  serializeJson(doc, output);
+  return output;
 }
 
 TEST_CASE("serializeJson(JsonVariant)") {
-  SECTION("Undefined") {
-    check(JsonVariant(), "null");
-  }
-
-  SECTION("Null string") {
-    check(static_cast<char*>(0), "null");
+  SECTION("JsonVariant") {
+    CHECK(serialize(JsonVariant()) == "null");
   }
 
   SECTION("const char*") {
-    check("hello", "\"hello\"");
+    CHECK(serialize(static_cast<const char*>(0)) == "null");
+    CHECK(serialize("hello") == "\"hello\"");
   }
 
-  SECTION("string") {
-    check("hello"_s, "\"hello\"");
-
-    SECTION("Escape quotation mark") {
-      check("hello \"world\""_s, "\"hello \\\"world\\\"\"");
-    }
-
-    SECTION("Escape reverse solidus") {
-      check("hello\\world"_s, "\"hello\\\\world\"");
-    }
-
-    SECTION("Don't escape solidus") {
-      check("fifty/fifty"_s, "\"fifty/fifty\"");
-    }
-
-    SECTION("Don't escape single quote") {
-      check("hello'world"_s, "\"hello'world\"");
-    }
-
-    SECTION("Escape backspace") {
-      check("hello\bworld"_s, "\"hello\\bworld\"");
-    }
-
-    SECTION("Escape formfeed") {
-      check("hello\fworld"_s, "\"hello\\fworld\"");
-    }
-
-    SECTION("Escape linefeed") {
-      check("hello\nworld"_s, "\"hello\\nworld\"");
-    }
-
-    SECTION("Escape carriage return") {
-      check("hello\rworld"_s, "\"hello\\rworld\"");
-    }
-
-    SECTION("Escape tab") {
-      check("hello\tworld"_s, "\"hello\\tworld\"");
-    }
-
-    SECTION("NUL char") {
-      check("hello\0world"_s, "\"hello\\u0000world\"");
-    }
+  SECTION("std::string") {
+    CHECK(serialize("hello"_s) == "\"hello\"");
+    CHECK(serialize("hello \"world\""_s) == "\"hello \\\"world\\\"\"");
+    CHECK(serialize("hello\\world"_s) == "\"hello\\\\world\"");
+    CHECK(serialize("fifty/fifty"_s) == "\"fifty/fifty\"");
+    CHECK(serialize("hello'world"_s) == "\"hello'world\"");
+    CHECK(serialize("hello\bworld"_s) == "\"hello\\bworld\"");
+    CHECK(serialize("hello\fworld"_s) == "\"hello\\fworld\"");
+    CHECK(serialize("hello\nworld"_s) == "\"hello\\nworld\"");
+    CHECK(serialize("hello\rworld"_s) == "\"hello\\rworld\"");
+    CHECK(serialize("hello\tworld"_s) == "\"hello\\tworld\"");
+    CHECK(serialize("hello\0world"_s) == "\"hello\\u0000world\"");
   }
 
   SECTION("SerializedValue<const char*>") {
-    check(serialized("[1,2]"), "[1,2]");
+    CHECK(serialize(serialized("[1,2]")) == "[1,2]");
   }
 
   SECTION("SerializedValue<std::string>") {
-    check(serialized("[1,2]"_s), "[1,2]");
+    CHECK(serialize(serialized("[1,2]"_s)) == "[1,2]");
   }
 
-  SECTION("Double") {
-    check(3.1415927, "3.1415927");
+  SECTION("double") {
+    CHECK(serialize(0.0) == "0");
+    CHECK(serialize(-0.0) == "0");
+    CHECK(serialize(10.0) == "10");
+    CHECK(serialize(100.0) == "100");
+    CHECK(serialize(0.1) == "0.1");
+    CHECK(serialize(0.01) == "0.01");
+    CHECK(serialize(3.1415927) == "3.1415927");
+    CHECK(serialize(-3.1415927) == "-3.1415927");
+    CHECK(serialize(1.7976931348623157E+308) == "1.79769313e308");
+    CHECK(serialize(4.94065645841247e-324) == "4.94065646e-324");
   }
 
-  SECTION("Float") {
+  SECTION("float") {
     REQUIRE(sizeof(float) == 4);
-    check(3.1415927f, "3.141593");
+    CHECK(serialize(3.1415927f) == "3.141593");
+    CHECK(serialize(-3.1415927f) == "-3.141593");
+    CHECK(serialize(3.4E+38f) == "3.4e38");
+    CHECK(serialize(1.17549435e-38f) == "1.175494e-38");
   }
 
-  SECTION("Zero") {
-    check(0, "0");
+  SECTION("int") {
+    CHECK(serialize(0) == "0");
+    CHECK(serialize(42) == "42");
+    CHECK(serialize(-42) == "-42");
   }
 
-  SECTION("Integer") {
-    check(42, "42");
+  SECTION("unsigned long") {
+    CHECK(serialize(4294967295UL) == "4294967295");
   }
 
-  SECTION("NegativeLong") {
-    check(-42, "-42");
-  }
-
-  SECTION("UnsignedLong") {
-    check(4294967295UL, "4294967295");
-  }
-
-  SECTION("True") {
-    check(true, "true");
-  }
-
-  SECTION("OneFalse") {
-    check(false, "false");
+  SECTION("bool") {
+    CHECK(serialize(true) == "true");
+    CHECK(serialize(false) == "false");
   }
 
 #if ARDUINOJSON_USE_LONG_LONG
-  SECTION("NegativeInt64") {
-    check(-9223372036854775807 - 1, "-9223372036854775808");
+  SECTION("int64_t") {
+    CHECK(serialize(-9223372036854775807 - 1) == "-9223372036854775808");
+    CHECK(serialize(9223372036854775807) == "9223372036854775807");
   }
 
-  SECTION("PositiveInt64") {
-    check(9223372036854775807, "9223372036854775807");
-  }
-
-  SECTION("UInt64") {
-    check(18446744073709551615U, "18446744073709551615");
+  SECTION("uint64_t") {
+    CHECK(serialize(18446744073709551615U) == "18446744073709551615");
   }
 #endif
 }

extras/tests/JsonVariant/as.cpp

@@ -185,7 +185,6 @@ TEST_CASE("JsonVariant::as()") {
     REQUIRE(variant.as<long>() == 42L);
     REQUIRE(variant.as<double>() == 42);
     REQUIRE(variant.as<JsonString>() == "42");
-    REQUIRE(variant.as<JsonString>().isStatic() == true);
   }
 
   SECTION("set(\"hello\")") {
@@ -208,7 +207,6 @@ TEST_CASE("JsonVariant::as()") {
     REQUIRE(variant.as<const char*>() == "4.2"_s);
     REQUIRE(variant.as<std::string>() == "4.2"_s);
     REQUIRE(variant.as<JsonString>() == "4.2");
-    REQUIRE(variant.as<JsonString>().isStatic() == false);
   }
 
   SECTION("set(std::string(\"123.45\"))") {
@@ -220,7 +218,6 @@ TEST_CASE("JsonVariant::as()") {
     REQUIRE(variant.as<const char*>() == "123.45"_s);
     REQUIRE(variant.as<std::string>() == "123.45"_s);
     REQUIRE(variant.as<JsonString>() == "123.45");
-    REQUIRE(variant.as<JsonString>().isStatic() == false);
   }
 
   SECTION("set(\"true\")") {

extras/tests/JsonVariant/copy.cpp

@@ -38,13 +38,15 @@ TEST_CASE("JsonVariant::set(JsonVariant)") {
     REQUIRE(var1.as<std::string>() == "{\"value\":[42]}");
   }
 
-  SECTION("stores const char* by reference") {
+  SECTION("stores string literals by copy") {
     var1.set("hello!!");
     spyingAllocator.clearLog();
 
     var2.set(var1);
 
-    REQUIRE(spyingAllocator.log() == AllocatorLog{});
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofString("hello!!")),
+                                     });
   }
 
   SECTION("stores char* by copy") {

extras/tests/JsonVariant/set.cpp

@@ -8,7 +8,7 @@
 #include "Allocators.hpp"
 #include "Literals.hpp"
 
-using ArduinoJson::detail::sizeofObject;
+using namespace ArduinoJson::detail;
 
 enum ErrorCode { ERROR_01 = 1, ERROR_10 = 10 };
 
@@ -18,12 +18,13 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
   JsonVariant variant = doc.to<JsonVariant>();
 
   SECTION("string literal") {
-    bool result = variant.set("hello\0world");
+    bool result = variant.set("hello world");
 
     REQUIRE(result == true);
-    CHECK(variant ==
-          "hello"_s);  // linked string cannot contain '\0' at the moment
-    CHECK(spy.log() == AllocatorLog{});
+    REQUIRE(variant == "hello world"_s);  // stores by copy
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofString(11)),
+                         });
   }
 
   SECTION("const char*") {
@@ -140,19 +141,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
                          });
   }
 
-  SECTION("static JsonString") {
-    char str[16];
-
-    strcpy(str, "hello");
-    bool result = variant.set(JsonString(str, true));
-    strcpy(str, "world");
-
-    REQUIRE(result == true);
-    REQUIRE(variant == "world");  // stores by pointer
-    REQUIRE(spy.log() == AllocatorLog{});
-  }
-
-  SECTION("non-static JsonString") {
+  SECTION("JsonString") {
     char str[16];
 
     strcpy(str, "hello");
@@ -193,11 +182,11 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
     REQUIRE(result == true);
     REQUIRE(variant.is<double>() == true);
     REQUIRE(variant.as<double>() == 1.2);
-    REQUIRE(spy.log() ==
-            AllocatorLog{
-                Allocate(sizeofPool()),
-                Reallocate(sizeofPool(), sizeofPool(1)),  // one extension slot
-            });
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool<EightByteValue>()),
+                             Reallocate(sizeofPool<EightByteValue>(),
+                                        sizeofPool<EightByteValue>(1)),
+                         });
   }
 
   SECTION("int32_t") {
@@ -216,11 +205,11 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
     REQUIRE(result == true);
     REQUIRE(variant.is<int64_t>() == true);
     REQUIRE(variant.as<int64_t>() == -2147483649LL);
-    REQUIRE(spy.log() ==
-            AllocatorLog{
-                Allocate(sizeofPool()),
-                Reallocate(sizeofPool(), sizeofPool(1)),  // one extension slot
-            });
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool<EightByteValue>()),
+                             Reallocate(sizeofPool<EightByteValue>(),
+                                        sizeofPool<EightByteValue>(1)),
+                         });
   }
 
   SECTION("uint32_t") {
@@ -239,11 +228,11 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
     REQUIRE(result == true);
     REQUIRE(variant.is<uint64_t>() == true);
     REQUIRE(variant.as<uint64_t>() == 4294967296);
-    REQUIRE(spy.log() ==
-            AllocatorLog{
-                Allocate(sizeofPool()),
-                Reallocate(sizeofPool(), sizeofPool(1)),  // one extension slot
-            });
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool<EightByteValue>()),
+                             Reallocate(sizeofPool<EightByteValue>(),
+                                        sizeofPool<EightByteValue>(1)),
+                         });
   }
 
   SECTION("JsonDocument") {
@@ -360,7 +349,7 @@ TEST_CASE("JsonVariant::set() releases the previous value") {
   }
 
   SECTION("float") {
-    v.set(1.2);
+    v.set(1.2f);
     REQUIRE(spy.log() == AllocatorLog{
                              Deallocate(sizeofString("world")),
                          });
@@ -375,7 +364,7 @@ TEST_CASE("JsonVariant::set() releases the previous value") {
   }
 }
 
-TEST_CASE("JsonVariant::set() reuses extension slot") {
+TEST_CASE("JsonVariant::set() reuses 8-bit slot") {
   SpyingAllocator spy;
   JsonDocument doc(&spy);
   JsonVariant variant = doc.to<JsonVariant>();

extras/tests/JsonVariantConst/subscript.cpp

@@ -52,12 +52,12 @@ TEST_CASE("JsonVariantConst::operator[]") {
     JsonObject object = doc.to<JsonObject>();
     object["ab"_s] = "AB";
     object["abc"_s] = "ABC";
-    object["abc\0d"_s] = "ABCD";
+    object["abcd"_s] = "ABCD";
 
     SECTION("string literal") {
       REQUIRE(var["ab"] == "AB"_s);
       REQUIRE(var["abc"] == "ABC"_s);
-      REQUIRE(var["abc\0d"] == "ABCD"_s);
+      REQUIRE(var["abcd"] == "ABCD"_s);
       REQUIRE(var["def"].isNull());
       REQUIRE(var[0].isNull());
     }
@@ -73,7 +73,7 @@ TEST_CASE("JsonVariantConst::operator[]") {
     SECTION("supports std::string") {
       REQUIRE(var["ab"_s] == "AB"_s);
       REQUIRE(var["abc"_s] == "ABC"_s);
-      REQUIRE(var["abc\0d"_s] == "ABCD"_s);
+      REQUIRE(var["abcd"_s] == "ABCD"_s);
       REQUIRE(var["def"_s].isNull());
     }
 
@@ -91,7 +91,7 @@ TEST_CASE("JsonVariantConst::operator[]") {
     SECTION("supports JsonVariant") {
       object["key1"] = "ab";
       object["key2"] = "abc";
-      object["key3"] = "abc\0d"_s;
+      object["key3"] = "abcd"_s;
       object["key4"] = "foo";
 
       REQUIRE(var[var["key1"]] == "AB"_s);

extras/tests/Misc/CMakeLists.txt

@@ -29,3 +29,23 @@ set_tests_properties(Misc
 	PROPERTIES
 		LABELS "Catch"
 )
+
+add_executable(Issue2181
+	issue2181.cpp # Cannot be linked with other tests
+)
+
+set_target_properties(Issue2181 PROPERTIES UNITY_BUILD OFF)
+
+add_test(Issue2181 Issue2181)
+
+set_tests_properties(Issue2181
+	PROPERTIES
+		LABELS "Catch"
+)
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+	target_compile_options(Issue2181
+		PRIVATE
+			-Wno-keyword-macro # keyword is hidden by macro definition
+	)
+endif()

extras/tests/Misc/JsonString.cpp

@@ -13,7 +13,6 @@ TEST_CASE("JsonString") {
 
     CHECK(s.isNull() == true);
     CHECK(s.c_str() == 0);
-    CHECK(s.isStatic() == true);
     CHECK(s == JsonString());
     CHECK(s != "");
   }
@@ -96,7 +95,6 @@ TEST_CASE("JsonString") {
     JsonString s("hello world", 5);
 
     CHECK(s.size() == 5);
-    CHECK(s.isStatic() == false);
     CHECK(s == "hello");
     CHECK(s != "hello world");
   }

extras/tests/Misc/StringAdapters.cpp

@@ -21,8 +21,7 @@ TEST_CASE("adaptString()") {
     auto s = adaptString("bravo\0alpha");
 
     CHECK(s.isNull() == false);
-    CHECK(s.size() == 11);
-    CHECK(s.isStatic() == true);
+    CHECK(s.size() == 5);
   }
 
   SECTION("null const char*") {
@@ -38,7 +37,6 @@ TEST_CASE("adaptString()") {
 
     CHECK(s.isNull() == false);
     CHECK(s.size() == 5);
-    CHECK(s.isStatic() == false);
     CHECK(s.data() == p);
   }
 
@@ -46,7 +44,6 @@ TEST_CASE("adaptString()") {
     auto s = adaptString(static_cast<const char*>(0), 10);
 
     CHECK(s.isNull() == true);
-    CHECK(s.isStatic() == false);
   }
 
   SECTION("non-null const char* + size") {
@@ -54,7 +51,6 @@ TEST_CASE("adaptString()") {
 
     CHECK(s.isNull() == false);
     CHECK(s.size() == 5);
-    CHECK(s.isStatic() == false);
   }
 
   SECTION("null Flash string") {
@@ -62,7 +58,6 @@ TEST_CASE("adaptString()") {
 
     CHECK(s.isNull() == true);
     CHECK(s.size() == 0);
-    CHECK(s.isStatic() == false);
   }
 
   SECTION("non-null Flash string") {
@@ -70,7 +65,6 @@ TEST_CASE("adaptString()") {
 
     CHECK(s.isNull() == false);
     CHECK(s.size() == 5);
-    CHECK(s.isStatic() == false);
   }
 
   SECTION("std::string") {
@@ -79,7 +73,6 @@ TEST_CASE("adaptString()") {
 
     CHECK(s.isNull() == false);
     CHECK(s.size() == 5);
-    CHECK(s.isStatic() == false);
   }
 
   SECTION("Arduino String") {
@@ -88,7 +81,6 @@ TEST_CASE("adaptString()") {
 
     CHECK(s.isNull() == false);
     CHECK(s.size() == 5);
-    CHECK(s.isStatic() == false);
   }
 
   SECTION("custom_string") {
@@ -97,25 +89,14 @@ TEST_CASE("adaptString()") {
 
     CHECK(s.isNull() == false);
     CHECK(s.size() == 5);
-    CHECK(s.isStatic() == false);
   }
 
-  SECTION("JsonString linked") {
-    JsonString orig("hello", true);
+  SECTION("JsonString") {
+    JsonString orig("hello");
     auto s = adaptString(orig);
 
     CHECK(s.isNull() == false);
     CHECK(s.size() == 5);
-    CHECK(s.isStatic() == true);
-  }
-
-  SECTION("JsonString copied") {
-    JsonString orig("hello", false);
-    auto s = adaptString(orig);
-
-    CHECK(s.isNull() == false);
-    CHECK(s.size() == 5);
-    CHECK(s.isStatic() == false);
   }
 }
 

extras/tests/Misc/issue2181.cpp

@@ -0,0 +1,15 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#define true 0x1
+#define false 0x0
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("Issue #2181") {
+  JsonDocument doc;
+  doc["hello"] = "world";
+  REQUIRE(doc.as<std::string>() == "{\"hello\":\"world\"}");
+}

extras/tests/MixedConfiguration/enable_alignment_0.cpp

@@ -2,6 +2,8 @@
 #define ARDUINOJSON_ENABLE_ALIGNMENT 0
 #include <ArduinoJson.h>
 
+#include <ArduinoJson/Memory/Alignment.hpp>
+
 #include <catch.hpp>
 
 TEST_CASE("ARDUINOJSON_ENABLE_ALIGNMENT == 0") {

extras/tests/MixedConfiguration/enable_alignment_1.cpp

@@ -1,6 +1,8 @@
 #define ARDUINOJSON_ENABLE_ALIGNMENT 1
 #include <ArduinoJson.h>
 
+#include <ArduinoJson/Memory/Alignment.hpp>
+
 #include <catch.hpp>
 
 TEST_CASE("ARDUINOJSON_ENABLE_ALIGNMENT == 1") {

extras/tests/MixedConfiguration/string_length_size_4.cpp

@@ -89,58 +89,71 @@ TEST_CASE("ARDUINOJSON_STRING_LENGTH_SIZE == 4") {
 
       REQUIRE(err != DeserializationError::Ok);
     }
+
+    SECTION("bin 32") {
+      auto str = std::string(65536, '?');
+      auto input = "\xc6\x00\x01\x00\x00"_s + str;
+
+      auto err = deserializeMsgPack(doc, input);
+
+      REQUIRE(err == DeserializationError::Ok);
+      REQUIRE(doc.is<MsgPackBinary>());
+      auto binary = doc.as<MsgPackBinary>();
+      REQUIRE(binary.size() == 65536);
+      REQUIRE(binary.data() != nullptr);
+      REQUIRE(std::string(reinterpret_cast<const char*>(binary.data()),
+                          binary.size()) == str);
+    }
+
+    SECTION("ext 32 deserialization") {
+      auto str = std::string(65536, '?');
+      auto input = "\xc9\x00\x01\x00\x00\x2a"_s + str;
+
+      auto err = deserializeMsgPack(doc, input);
+
+      REQUIRE(err == DeserializationError::Ok);
+      REQUIRE(doc.is<MsgPackExtension>());
+      auto value = doc.as<MsgPackExtension>();
+      REQUIRE(value.type() == 42);
+      REQUIRE(value.size() == 65536);
+      REQUIRE(value.data() != nullptr);
+      REQUIRE(std::string(reinterpret_cast<const char*>(value.data()),
+                          value.size()) == str);
+    }
   }
 
-  SECTION("bin 32 deserialization") {
-    auto str = std::string(65536, '?');
-    auto input = "\xc6\x00\x01\x00\x00"_s + str;
+  SECTION("serializeMsgPack()") {
+    SECTION("bin 32 serialization") {
+      auto str = std::string(65536, '?');
+      doc.set(MsgPackBinary(str.data(), str.size()));
 
-    auto err = deserializeMsgPack(doc, input);
+      std::string output;
+      auto result = serializeMsgPack(doc, output);
 
-    REQUIRE(err == DeserializationError::Ok);
-    REQUIRE(doc.is<MsgPackBinary>());
-    auto binary = doc.as<MsgPackBinary>();
-    REQUIRE(binary.size() == 65536);
-    REQUIRE(binary.data() != nullptr);
-    REQUIRE(std::string(reinterpret_cast<const char*>(binary.data()),
-                        binary.size()) == str);
-  }
+      REQUIRE(result == 5 + str.size());
+      REQUIRE(output == "\xc6\x00\x01\x00\x00"_s + str);
+    }
 
-  SECTION("bin 32 serialization") {
-    auto str = std::string(65536, '?');
-    doc.set(MsgPackBinary(str.data(), str.size()));
+    SECTION("ext 32 serialization") {
+      auto str = std::string(65536, '?');
+      doc.set(MsgPackExtension(42, str.data(), str.size()));
 
-    std::string output;
-    auto result = serializeMsgPack(doc, output);
+      std::string output;
+      auto result = serializeMsgPack(doc, output);
 
-    REQUIRE(result == 5 + str.size());
-    REQUIRE(output == "\xc6\x00\x01\x00\x00"_s + str);
-  }
+      REQUIRE(result == 6 + str.size());
+      REQUIRE(output == "\xc9\x00\x01\x00\x00\x2a"_s + str);
+    }
 
-  SECTION("ext 32 deserialization") {
-    auto str = std::string(65536, '?');
-    auto input = "\xc9\x00\x01\x00\x00\x2a"_s + str;
+    SECTION("str 32 serialization") {
+      auto str = std::string(65536, '?');
+      doc.set(str);
 
-    auto err = deserializeMsgPack(doc, input);
+      std::string output;
+      auto result = serializeMsgPack(doc, output);
 
-    REQUIRE(err == DeserializationError::Ok);
-    REQUIRE(doc.is<MsgPackExtension>());
-    auto value = doc.as<MsgPackExtension>();
-    REQUIRE(value.type() == 42);
-    REQUIRE(value.size() == 65536);
-    REQUIRE(value.data() != nullptr);
-    REQUIRE(std::string(reinterpret_cast<const char*>(value.data()),
-                        value.size()) == str);
-  }
-
-  SECTION("ext 32 serialization") {
-    auto str = std::string(65536, '?');
-    doc.set(MsgPackExtension(42, str.data(), str.size()));
-
-    std::string output;
-    auto result = serializeMsgPack(doc, output);
-
-    REQUIRE(result == 6 + str.size());
-    REQUIRE(output == "\xc9\x00\x01\x00\x00\x2a"_s + str);
+      REQUIRE(result == 5 + str.size());
+      REQUIRE(output == "\xDB\x00\x01\x00\x00"_s + str);
+    }
   }
 }

extras/tests/MsgPackDeserializer/destination_types.cpp

@@ -104,6 +104,8 @@ TEST_CASE("deserializeMsgPack(MemberProxy)") {
 
     REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.as<std::string>() == "{\"hello\":\"world\",\"value\":[42]}");
-    REQUIRE(spy.log() == AllocatorLog{});
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofString("value")),
+                         });
   }
 }

extras/tests/MsgPackSerializer/serializeVariant.cpp

@@ -137,11 +137,12 @@ TEST_CASE("serialize MsgPack value") {
     checkVariant(longest.c_str(), "\xDA\xFF\xFF"_s + longest);
   }
 
+#if ARDUINOJSON_STRING_LENGTH_SIZE > 2
   SECTION("str 32") {
     std::string shortest(65536, '?');
-    checkVariant(JsonString(shortest.c_str(), true),  // force store by pointer
-                 "\xDB\x00\x01\x00\x00"_s + shortest);
+    checkVariant(shortest.c_str(), "\xDB\x00\x01\x00\x00"_s + shortest);
   }
+#endif
 
   SECTION("serialized(const char*)") {
     checkVariant(serialized("\xDA\xFF\xFF"), "\xDA\xFF\xFF");

extras/tests/Numbers/CMakeLists.txt

@@ -4,7 +4,6 @@
 
 add_executable(NumbersTests
 	convertNumber.cpp
-	decomposeFloat.cpp
 	parseDouble.cpp
 	parseFloat.cpp
 	parseInteger.cpp

extras/tests/Numbers/decomposeFloat.cpp

@@ -1,42 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2025, Benoit BLANCHON
-// MIT License
-
-#include <ArduinoJson/Numbers/FloatParts.hpp>
-#include <catch.hpp>
-
-using namespace ArduinoJson::detail;
-
-TEST_CASE("decomposeFloat()") {
-  SECTION("1.7976931348623157E+308") {
-    auto parts = decomposeFloat(1.7976931348623157E+308, 9);
-    REQUIRE(parts.integral == 1);
-    REQUIRE(parts.decimal == 797693135);
-    REQUIRE(parts.decimalPlaces == 9);
-    REQUIRE(parts.exponent == 308);
-  }
-
-  SECTION("4.94065645841247e-324") {
-    auto parts = decomposeFloat(4.94065645841247e-324, 9);
-    REQUIRE(parts.integral == 4);
-    REQUIRE(parts.decimal == 940656458);
-    REQUIRE(parts.decimalPlaces == 9);
-    REQUIRE(parts.exponent == -324);
-  }
-
-  SECTION("3.4E+38") {
-    auto parts = decomposeFloat(3.4E+38f, 6);
-    REQUIRE(parts.integral == 3);
-    REQUIRE(parts.decimal == 4);
-    REQUIRE(parts.decimalPlaces == 1);
-    REQUIRE(parts.exponent == 38);
-  }
-
-  SECTION("1.17549435e−38") {
-    auto parts = decomposeFloat(1.17549435e-38f, 6);
-    REQUIRE(parts.integral == 1);
-    REQUIRE(parts.decimal == 175494);
-    REQUIRE(parts.decimalPlaces == 6);
-    REQUIRE(parts.exponent == -38);
-  }
-}

extras/tests/ResourceManager/StringBuffer.cpp

@@ -3,6 +3,7 @@
 // MIT License
 
 #include <ArduinoJson/Memory/StringBuffer.hpp>
+#include <ArduinoJson/Variant/VariantImpl.hpp>
 #include <catch.hpp>
 
 #include "Allocators.hpp"
@@ -21,7 +22,7 @@ TEST_CASE("StringBuffer") {
     strcpy(ptr, "hi!");
     sb.save(&variant);
 
-    REQUIRE(variant.type() == VariantType::TinyString);
+    REQUIRE(variant.type == VariantType::TinyString);
     REQUIRE(variant.asString() == "hi!");
   }
 
@@ -30,7 +31,7 @@ TEST_CASE("StringBuffer") {
     memcpy(ptr, "a\0b", 3);
     sb.save(&variant);
 
-    REQUIRE(variant.type() == VariantType::OwnedString);
+    REQUIRE(variant.type == VariantType::LongString);
 
     auto str = variant.asString();
     REQUIRE(str.size() == 3);
@@ -44,7 +45,7 @@ TEST_CASE("StringBuffer") {
     strcpy(ptr, "alfa");
     sb.save(&variant);
 
-    REQUIRE(variant.type() == VariantType::OwnedString);
+    REQUIRE(variant.type == VariantType::LongString);
     REQUIRE(variant.asString() == "alfa");
   }
 }

extras/tests/ResourceManager/StringBuilder.cpp

@@ -3,6 +3,7 @@
 // MIT License
 
 #include <ArduinoJson/Memory/StringBuilder.hpp>
+#include <ArduinoJson/Variant/VariantImpl.hpp>
 #include <catch.hpp>
 
 #include "Allocators.hpp"
@@ -26,7 +27,7 @@ TEST_CASE("StringBuilder") {
     REQUIRE(spyingAllocator.log() == AllocatorLog{
                                          Allocate(sizeofStringBuffer()),
                                      });
-    REQUIRE(data.type() == VariantType::TinyString);
+    REQUIRE(data.type == VariantType::TinyString);
   }
 
   SECTION("Tiny string") {
@@ -45,7 +46,7 @@ TEST_CASE("StringBuilder") {
     str.save(&data);
 
     REQUIRE(resources.overflowed() == false);
-    REQUIRE(data.type() == VariantType::TinyString);
+    REQUIRE(data.type == VariantType::TinyString);
     REQUIRE(data.asString() == "url");
   }
 
@@ -116,12 +117,12 @@ TEST_CASE("StringBuilder") {
   }
 }
 
-static JsonString saveString(StringBuilder& builder, const char* s) {
+static VariantData saveString(StringBuilder& builder, const char* s) {
   VariantData data;
   builder.startString();
   builder.append(s);
   builder.save(&data);
-  return data.asString();
+  return data;
 }
 
 TEST_CASE("StringBuilder::save() deduplicates strings") {
@@ -134,9 +135,9 @@ TEST_CASE("StringBuilder::save() deduplicates strings") {
     auto s2 = saveString(builder, "world");
     auto s3 = saveString(builder, "hello");
 
-    REQUIRE(s1 == "hello");
-    REQUIRE(s2 == "world");
-    REQUIRE(+s1.c_str() == +s3.c_str());  // same address
+    REQUIRE(s1.asString() == "hello");
+    REQUIRE(s2.asString() == "world");
+    REQUIRE(+s1.asString().c_str() == +s3.asString().c_str());  // same address
 
     REQUIRE(spy.log() ==
             AllocatorLog{
@@ -152,9 +153,10 @@ TEST_CASE("StringBuilder::save() deduplicates strings") {
     auto s1 = saveString(builder, "hello world");
     auto s2 = saveString(builder, "hello");
 
-    REQUIRE(s1 == "hello world");
-    REQUIRE(s2 == "hello");
-    REQUIRE(+s2.c_str() != +s1.c_str());  // different address
+    REQUIRE(s1.asString() == "hello world");
+    REQUIRE(s2.asString() == "hello");
+    REQUIRE(+s2.asString().c_str() !=
+            +s1.asString().c_str());  // different address
 
     REQUIRE(spy.log() ==
             AllocatorLog{
@@ -169,9 +171,10 @@ TEST_CASE("StringBuilder::save() deduplicates strings") {
     auto s1 = saveString(builder, "hello world");
     auto s2 = saveString(builder, "worl");
 
-    REQUIRE(s1 == "hello world");
-    REQUIRE(s2 == "worl");
-    REQUIRE(s2.c_str() != s1.c_str());  // different address
+    REQUIRE(s1.asString() == "hello world");
+    REQUIRE(s2.asString() == "worl");
+    REQUIRE(s2.asString().c_str() !=
+            s1.asString().c_str());  // different address
 
     REQUIRE(spy.log() ==
             AllocatorLog{

extras/tests/ResourceManager/allocVariant.cpp

@@ -5,6 +5,8 @@
 #include <ArduinoJson.hpp>
 #include <catch.hpp>
 
+#include <ArduinoJson/Memory/Alignment.hpp>
+
 #include "Allocators.hpp"
 
 using namespace ArduinoJson::detail;

extras/tests/ResourceManager/clear.cpp

@@ -3,8 +3,8 @@
 // MIT License
 
 #include <ArduinoJson/Memory/ResourceManager.hpp>
-#include <ArduinoJson/Memory/ResourceManagerImpl.hpp>
 #include <ArduinoJson/Strings/StringAdapters.hpp>
+
 #include <catch.hpp>
 
 using namespace ArduinoJson::detail;

extras/tests/ResourceManager/shrinkToFit.cpp

@@ -3,7 +3,7 @@
 // MIT License
 
 #include <ArduinoJson/Memory/ResourceManager.hpp>
-#include <ArduinoJson/Memory/ResourceManagerImpl.hpp>
+
 #include <catch.hpp>
 
 #include "Allocators.hpp"

extras/tests/ResourceManager/size.cpp

@@ -3,7 +3,7 @@
 // MIT License
 
 #include <ArduinoJson/Memory/ResourceManager.hpp>
-#include <ArduinoJson/Memory/ResourceManagerImpl.hpp>
+
 #include <catch.hpp>
 
 #include "Allocators.hpp"

extras/tests/ResourceManager/swap.cpp

@@ -4,7 +4,7 @@
 
 #include <ArduinoJson/Memory/Alignment.hpp>
 #include <ArduinoJson/Memory/ResourceManager.hpp>
-#include <ArduinoJson/Memory/ResourceManagerImpl.hpp>
+
 #include <catch.hpp>
 
 #include "Allocators.hpp"

extras/tests/TextFormatter/writeFloat.cpp

@@ -14,106 +14,112 @@
 using namespace ArduinoJson::detail;
 
 template <typename TFloat>
-void check(TFloat input, const std::string& expected) {
+static std::string toString(TFloat input) {
   std::string output;
   Writer<std::string> sb(output);
   TextFormatter<Writer<std::string>> writer(sb);
   writer.writeFloat(input);
-  REQUIRE(writer.bytesWritten() == output.size());
-  CHECK(expected == output);
+  return output;
 }
 
 TEST_CASE("TextFormatter::writeFloat(double)") {
   SECTION("Pi") {
-    check<double>(3.14159265359, "3.141592654");
+    REQUIRE(toString(3.14159265359) == "3.14159265");
   }
 
   SECTION("Signaling NaN") {
     double nan = std::numeric_limits<double>::signaling_NaN();
-    check<double>(nan, "NaN");
+    REQUIRE(toString(nan) == "NaN");
   }
 
   SECTION("Quiet NaN") {
     double nan = std::numeric_limits<double>::quiet_NaN();
-    check<double>(nan, "NaN");
+    REQUIRE(toString(nan) == "NaN");
   }
 
   SECTION("Infinity") {
     double inf = std::numeric_limits<double>::infinity();
-    check<double>(inf, "Infinity");
-    check<double>(-inf, "-Infinity");
+    REQUIRE(toString(inf) == "Infinity");
+    REQUIRE(toString(-inf) == "-Infinity");
   }
 
   SECTION("Zero") {
-    check<double>(0.0, "0");
-    check<double>(-0.0, "0");
+    REQUIRE(toString(0.0) == "0");
+    REQUIRE(toString(-0.0) == "0");
   }
 
   SECTION("Espilon") {
-    check<double>(2.2250738585072014E-308, "2.225073859e-308");
-    check<double>(-2.2250738585072014E-308, "-2.225073859e-308");
+    REQUIRE(toString(2.2250738585072014E-308) == "2.22507386e-308");
+    REQUIRE(toString(-2.2250738585072014E-308) == "-2.22507386e-308");
   }
 
   SECTION("Max double") {
-    check<double>(1.7976931348623157E+308, "1.797693135e308");
-    check<double>(-1.7976931348623157E+308, "-1.797693135e308");
+    REQUIRE(toString(1.7976931348623157E+308) == "1.79769313e308");
+    REQUIRE(toString(-1.7976931348623157E+308) == "-1.79769313e308");
   }
 
   SECTION("Big exponent") {
-    // this test increases coverage of normalize()
-    check<double>(1e255, "1e255");
-    check<double>(1e-255, "1e-255");
+    REQUIRE(toString(1e255) == "1e255");
+    REQUIRE(toString(1e-255) == "1e-255");
   }
 
   SECTION("Exponentation when <= 1e-5") {
-    check<double>(1e-4, "0.0001");
-    check<double>(1e-5, "1e-5");
+    REQUIRE(toString(1e-4) == "0.0001");
+    REQUIRE(toString(1e-5) == "1e-5");
 
-    check<double>(-1e-4, "-0.0001");
-    check<double>(-1e-5, "-1e-5");
+    REQUIRE(toString(-1e-4) == "-0.0001");
+    REQUIRE(toString(-1e-5) == "-1e-5");
   }
 
   SECTION("Exponentation when >= 1e7") {
-    check<double>(9999999.999, "9999999.999");
-    check<double>(10000000.0, "1e7");
+    REQUIRE(toString(9999999.99) == "9999999.99");
+    REQUIRE(toString(10000000.0) == "1e7");
 
-    check<double>(-9999999.999, "-9999999.999");
-    check<double>(-10000000.0, "-1e7");
+    REQUIRE(toString(-9999999.99) == "-9999999.99");
+    REQUIRE(toString(-10000000.0) == "-1e7");
   }
 
   SECTION("Rounding when too many decimals") {
-    check<double>(0.000099999999999, "0.0001");
-    check<double>(0.0000099999999999, "1e-5");
-    check<double>(0.9999999996, "1");
+    REQUIRE(toString(0.000099999999999) == "0.0001");
+    REQUIRE(toString(0.0000099999999999) == "1e-5");
+    REQUIRE(toString(0.9999999996) == "1");
   }
 
   SECTION("9 decimal places") {
-    check<double>(0.100000001, "0.100000001");
-    check<double>(0.999999999, "0.999999999");
+    REQUIRE(toString(0.10000001) == "0.10000001");
+    REQUIRE(toString(0.99999999) == "0.99999999");
 
-    check<double>(9.000000001, "9.000000001");
-    check<double>(9.999999999, "9.999999999");
+    REQUIRE(toString(9.00000001) == "9.00000001");
+    REQUIRE(toString(9.99999999) == "9.99999999");
+  }
+
+  SECTION("9 decimal places") {
+    REQUIRE(toString(0.100000001) == "0.100000001");
+    REQUIRE(toString(0.999999999) == "0.999999999");
+
+    REQUIRE(toString(9.000000001) == "9");
+    REQUIRE(toString(9.999999999) == "10");
   }
 
   SECTION("10 decimal places") {
-    check<double>(0.1000000001, "0.1");
-    check<double>(0.9999999999, "1");
+    REQUIRE(toString(0.1000000001) == "0.1");
+    REQUIRE(toString(0.9999999999) == "1");
 
-    check<double>(9.0000000001, "9");
-    check<double>(9.9999999999, "10");
+    REQUIRE(toString(9.0000000001) == "9");
+    REQUIRE(toString(9.9999999999) == "10");
   }
 }
 
 TEST_CASE("TextFormatter::writeFloat(float)") {
   SECTION("Pi") {
-    check<float>(3.14159265359f, "3.141593");
+    REQUIRE(toString(3.14159265359f) == "3.141593");
   }
 
   SECTION("999.9") {  // issue #543
-    check<float>(999.9f, "999.9");
+    REQUIRE(toString(999.9f) == "999.9");
   }
 
   SECTION("24.3") {  // # issue #588
-    check<float>(24.3f, "24.3");
+    REQUIRE(toString(24.3f) == "24.3");
   }
 }

idf_component.yml

@@ -1,7 +1,7 @@
-version: "7.4.1"
+version: "7.4.2"
 description: >-
   A simple and efficient JSON library for embedded C++.
-  ★ 6898 stars on GitHub!
+  ★ 6953 stars on GitHub!
   Supports serialization, deserialization, MessagePack, streams, filtering, and more.
   Fully tested and documented.
 url: https://arduinojson.org/

library.json

@@ -1,13 +1,13 @@
 {
   "name": "ArduinoJson",
   "keywords": "json, rest, http, web",
-  "description": "A simple and efficient JSON library for embedded C++. ⭐ 6898 stars on GitHub! Supports serialization, deserialization, MessagePack, streams, filtering, and more. Fully tested and documented.",
+  "description": "A simple and efficient JSON library for embedded C++. ⭐ 6953 stars on GitHub! Supports serialization, deserialization, MessagePack, streams, filtering, and more. Fully tested and documented.",
   "homepage": "https://arduinojson.org/?utm_source=meta&utm_medium=library.json",
   "repository": {
     "type": "git",
     "url": "https://github.com/bblanchon/ArduinoJson.git"
   },
-  "version": "7.4.1",
+  "version": "7.4.2",
   "authors": {
     "name": "Benoit Blanchon",
     "url": "https://blog.benoitblanchon.fr"

library.properties

@@ -1,9 +1,9 @@
 name=ArduinoJson
-version=7.4.1
+version=7.4.2
 author=Benoit Blanchon <blog.benoitblanchon.fr>
 maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
 sentence=A simple and efficient JSON library for embedded C++.
-paragraph=⭐ 6898 stars on GitHub! Supports serialization, deserialization, MessagePack, streams, filtering, and more. Fully tested and documented.
+paragraph=⭐ 6953 stars on GitHub! Supports serialization, deserialization, MessagePack, streams, filtering, and more. Fully tested and documented.
 category=Data Processing
 url=https://arduinojson.org/?utm_source=meta&utm_medium=library.properties
 architectures=*

src/ArduinoJson.hpp

@@ -26,6 +26,15 @@
 #  endif
 #endif
 
+// Remove true and false macros defined by some cores, such as Arduino Due's
+// See issues #2181 and arduino/ArduinoCore-sam#50
+#ifdef true
+#  undef true
+#endif
+#ifdef false
+#  undef false
+#endif
+
 #include "ArduinoJson/Array/JsonArray.hpp"
 #include "ArduinoJson/Object/JsonObject.hpp"
 #include "ArduinoJson/Variant/JsonVariantConst.hpp"
@@ -36,13 +45,11 @@
 #include "ArduinoJson/Array/ElementProxy.hpp"
 #include "ArduinoJson/Array/Utilities.hpp"
 #include "ArduinoJson/Collection/CollectionImpl.hpp"
-#include "ArduinoJson/Memory/ResourceManagerImpl.hpp"
 #include "ArduinoJson/Object/MemberProxy.hpp"
 #include "ArduinoJson/Object/ObjectImpl.hpp"
 #include "ArduinoJson/Variant/ConverterImpl.hpp"
 #include "ArduinoJson/Variant/JsonVariantCopier.hpp"
 #include "ArduinoJson/Variant/VariantCompare.hpp"
-#include "ArduinoJson/Variant/VariantImpl.hpp"
 #include "ArduinoJson/Variant/VariantRefBaseImpl.hpp"
 
 #include "ArduinoJson/Json/JsonDeserializer.hpp"

src/ArduinoJson/Array/ArrayData.hpp

@@ -1,66 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2025, Benoit BLANCHON
-// MIT License
-
-#pragma once
-
-#include <ArduinoJson/Collection/CollectionData.hpp>
-
-ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
-
-class ArrayData : public CollectionData {
- public:
-  VariantData* addElement(ResourceManager* resources);
-
-  static VariantData* addElement(ArrayData* array, ResourceManager* resources) {
-    if (!array)
-      return nullptr;
-    return array->addElement(resources);
-  }
-
-  template <typename T>
-  bool addValue(const T& value, ResourceManager* resources);
-
-  template <typename T>
-  static bool addValue(ArrayData* array, const T& value,
-                       ResourceManager* resources) {
-    if (!array)
-      return false;
-    return array->addValue(value, resources);
-  }
-
-  VariantData* getOrAddElement(size_t index, ResourceManager* resources);
-
-  VariantData* getElement(size_t index, const ResourceManager* resources) const;
-
-  static VariantData* getElement(const ArrayData* array, size_t index,
-                                 const ResourceManager* resources) {
-    if (!array)
-      return nullptr;
-    return array->getElement(index, resources);
-  }
-
-  void removeElement(size_t index, ResourceManager* resources);
-
-  static void removeElement(ArrayData* array, size_t index,
-                            ResourceManager* resources) {
-    if (!array)
-      return;
-    array->removeElement(index, resources);
-  }
-
-  void remove(iterator it, ResourceManager* resources) {
-    CollectionData::removeOne(it, resources);
-  }
-
-  static void remove(ArrayData* array, iterator it,
-                     ResourceManager* resources) {
-    if (array)
-      return array->remove(it, resources);
-  }
-
- private:
-  iterator at(size_t index, const ResourceManager* resources) const;
-};
-
-ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Array/ArrayImpl.hpp

@@ -4,42 +4,47 @@
 
 #pragma once
 
-#include <ArduinoJson/Array/ArrayData.hpp>
 #include <ArduinoJson/Variant/VariantCompare.hpp>
-#include <ArduinoJson/Variant/VariantData.hpp>
+#include <ArduinoJson/Variant/VariantImpl.hpp>
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
-inline ArrayData::iterator ArrayData::at(
-    size_t index, const ResourceManager* resources) const {
-  auto it = createIterator(resources);
+inline VariantImpl::iterator VariantImpl::at(size_t index) const {
+  if (!isArray())
+    return iterator();
+
+  auto it = createIterator();
   while (!it.done() && index) {
-    it.next(resources);
+    it.move(resources_);
     --index;
   }
   return it;
 }
 
-inline VariantData* ArrayData::addElement(ResourceManager* resources) {
+inline VariantData* VariantImpl::addNewElement(VariantData* data,
+                                               ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->isArray());
+  ARDUINOJSON_ASSERT(resources != nullptr);
+
   auto slot = resources->allocVariant();
   if (!slot)
     return nullptr;
-  CollectionData::appendOne(slot, resources);
+  addElement(slot, data, resources);
   return slot.ptr();
 }
 
-inline VariantData* ArrayData::getOrAddElement(size_t index,
-                                               ResourceManager* resources) {
-  auto it = createIterator(resources);
+inline VariantData* VariantImpl::getOrAddElement(size_t index) {
+  auto it = createIterator();
   while (!it.done() && index > 0) {
-    it.next(resources);
+    it.move(resources_);
     index--;
   }
   if (it.done())
     index++;
   VariantData* element = it.data();
   while (index > 0) {
-    element = addElement(resources);
+    element = addNewElement();
     if (!element)
       return nullptr;
     index--;
@@ -47,33 +52,17 @@ inline VariantData* ArrayData::getOrAddElement(size_t index,
   return element;
 }
 
-inline VariantData* ArrayData::getElement(
-    size_t index, const ResourceManager* resources) const {
-  return at(index, resources).data();
+inline VariantData* VariantImpl::getElement(size_t index) const {
+  return at(index).data();
 }
 
-inline void ArrayData::removeElement(size_t index, ResourceManager* resources) {
-  remove(at(index, resources), resources);
-}
-
-template <typename T>
-inline bool ArrayData::addValue(const T& value, ResourceManager* resources) {
-  ARDUINOJSON_ASSERT(resources != nullptr);
-  auto slot = resources->allocVariant();
-  if (!slot)
-    return false;
-  JsonVariant variant(slot.ptr(), resources);
-  if (!variant.set(value)) {
-    resources->freeVariant(slot);
-    return false;
-  }
-  CollectionData::appendOne(slot, resources);
-  return true;
+inline void VariantImpl::removeElement(size_t index) {
+  removeElement(at(index));
 }
 
 // Returns the size (in bytes) of an array with n elements.
 constexpr size_t sizeofArray(size_t n) {
-  return n * ResourceManager::slotSize;
+  return n * sizeof(VariantData);
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Array/ElementProxy.hpp

@@ -55,17 +55,15 @@ class ElementProxy : public VariantRefBase<ElementProxy<TUpstream>>,
   }
 
   FORCE_INLINE VariantData* getData() const {
-    return VariantData::getElement(
-        VariantAttorney::getData(upstream_), index_,
-        VariantAttorney::getResourceManager(upstream_));
+    return VariantAttorney::getVariantImpl(upstream_).getElement(index_);
   }
 
   VariantData* getOrCreateData() const {
     auto data = VariantAttorney::getOrCreateData(upstream_);
-    if (!data)
-      return nullptr;
-    return data->getOrAddElement(
-        index_, VariantAttorney::getResourceManager(upstream_));
+    auto resources = VariantAttorney::getResourceManager(upstream_);
+    if (data && data->type == VariantType::Null)
+      data->toArray();
+    return VariantImpl(data, resources).getOrAddElement(index_);
   }
 
   TUpstream upstream_;

src/ArduinoJson/Array/JsonArray.hpp

@@ -20,24 +20,25 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
   using iterator = JsonArrayIterator;
 
   // Constructs an unbound reference.
-  JsonArray() : data_(0), resources_(0) {}
+  JsonArray() {}
 
   // INTERNAL USE ONLY
-  JsonArray(detail::ArrayData* data, detail::ResourceManager* resources)
-      : data_(data), resources_(resources) {}
+  JsonArray(detail::VariantData* data, detail::ResourceManager* resources)
+      : impl_(data, resources) {}
+
+  // INTERNAL USE ONLY
+  JsonArray(const detail::VariantImpl& impl) : impl_(impl) {}
 
   // Returns a JsonVariant pointing to the array.
   // https://arduinojson.org/v7/api/jsonvariant/
   operator JsonVariant() {
-    void* data = data_;  // prevent warning cast-align
-    return JsonVariant(reinterpret_cast<detail::VariantData*>(data),
-                       resources_);
+    return JsonVariant(getData(), getResourceManager());
   }
 
   // Returns a read-only reference to the array.
   // https://arduinojson.org/v7/api/jsonarrayconst/
   operator JsonArrayConst() const {
-    return JsonArrayConst(data_, resources_);
+    return JsonArrayConst(getData(), getResourceManager());
   }
 
   // Appends a new (empty) element to the array.
@@ -55,15 +56,16 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
   template <typename T, detail::enable_if_t<
                             detail::is_same<T, JsonVariant>::value, int> = 0>
   JsonVariant add() const {
-    return JsonVariant(detail::ArrayData::addElement(data_, resources_),
-                       resources_);
+    return JsonVariant(impl_.addNewElement(), impl_.resources());
   }
 
   // Appends a value to the array.
   // https://arduinojson.org/v7/api/jsonarray/add/
   template <typename T>
   bool add(const T& value) const {
-    return detail::ArrayData::addValue(data_, value, resources_);
+    if (!impl_.isArray())
+      return false;
+    return addValue(value, impl_.data(), impl_.resources());
   }
 
   // Appends a value to the array.
@@ -71,15 +73,15 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
   template <typename T,
             detail::enable_if_t<!detail::is_const<T>::value, int> = 0>
   bool add(T* value) const {
-    return detail::ArrayData::addValue(data_, value, resources_);
+    if (!impl_.isArray())
+      return false;
+    return addValue(value, impl_.data(), impl_.resources());
   }
 
   // Returns an iterator to the first element of the array.
   // https://arduinojson.org/v7/api/jsonarray/begin/
   iterator begin() const {
-    if (!data_)
-      return iterator();
-    return iterator(data_->createIterator(resources_), resources_);
+    return iterator(impl_.createIterator(), impl_.resources());
   }
 
   // Returns an iterator following the last element of the array.
@@ -91,9 +93,6 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
   // Copies an array.
   // https://arduinojson.org/v7/api/jsonarray/set/
   bool set(JsonArrayConst src) const {
-    if (!data_)
-      return false;
-
     clear();
     for (auto element : src) {
       if (!add(element))
@@ -106,13 +105,13 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
   // Removes the element at the specified iterator.
   // https://arduinojson.org/v7/api/jsonarray/remove/
   void remove(iterator it) const {
-    detail::ArrayData::remove(data_, it.iterator_, resources_);
+    impl_.removeElement(it.iterator_);
   }
 
   // Removes the element at the specified index.
   // https://arduinojson.org/v7/api/jsonarray/remove/
   void remove(size_t index) const {
-    detail::ArrayData::removeElement(data_, index, resources_);
+    impl_.removeElement(index);
   }
 
   // Removes the element at the specified index.
@@ -127,7 +126,7 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
   // Removes all the elements of the array.
   // https://arduinojson.org/v7/api/jsonarray/clear/
   void clear() const {
-    detail::ArrayData::clear(data_, resources_);
+    impl_.empty();
   }
 
   // Gets or sets the element at the specified index.
@@ -150,31 +149,31 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
   }
 
   operator JsonVariantConst() const {
-    return JsonVariantConst(collectionToVariant(data_), resources_);
+    return JsonVariantConst(getData(), getResourceManager());
   }
 
   // Returns true if the reference is unbound.
   // https://arduinojson.org/v7/api/jsonarray/isnull/
   bool isNull() const {
-    return data_ == 0;
+    return impl_.isNull();
   }
 
   // Returns true if the reference is bound.
   // https://arduinojson.org/v7/api/jsonarray/isnull/
   operator bool() const {
-    return data_ != 0;
+    return !isNull();
   }
 
   // Returns the depth (nesting level) of the array.
   // https://arduinojson.org/v7/api/jsonarray/nesting/
   size_t nesting() const {
-    return detail::VariantData::nesting(collectionToVariant(data_), resources_);
+    return impl_.nesting();
   }
 
   // Returns the number of elements in the array.
   // https://arduinojson.org/v7/api/jsonarray/size/
   size_t size() const {
-    return data_ ? data_->size(resources_) : 0;
+    return impl_.size();
   }
 
   // DEPRECATED: use add<JsonVariant>() instead
@@ -201,19 +200,40 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
 
  private:
   detail::ResourceManager* getResourceManager() const {
-    return resources_;
+    return impl_.resources();
   }
 
   detail::VariantData* getData() const {
-    return collectionToVariant(data_);
+    return impl_.data();
   }
 
   detail::VariantData* getOrCreateData() const {
-    return collectionToVariant(data_);
+    return impl_.data();
   }
 
-  detail::ArrayData* data_;
-  detail::ResourceManager* resources_;
+  // HACK: this function has been pulled out of VariantImpl to avoid the
+  // circular dependency between VariantImpl and JsonVariant
+  template <typename T>
+  static bool addValue(const T& value, detail::VariantData* data,
+                       detail::ResourceManager* resources) {
+    ARDUINOJSON_ASSERT(data != nullptr);
+    ARDUINOJSON_ASSERT(data->isArray());
+    ARDUINOJSON_ASSERT(resources != nullptr);
+
+    auto slot = resources->allocVariant();
+    if (!slot)
+      return false;
+
+    if (!JsonVariant(slot.ptr(), resources).set(value)) {
+      detail::VariantImpl::freeVariant(slot, resources);
+      return false;
+    }
+
+    detail::VariantImpl::addElement(slot, data, resources);
+    return true;
+  }
+
+  mutable detail::VariantImpl impl_;
 };
 
 ARDUINOJSON_END_PUBLIC_NAMESPACE

src/ArduinoJson/Array/JsonArrayConst.hpp

@@ -24,9 +24,7 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
   // Returns an iterator to the first element of the array.
   // https://arduinojson.org/v7/api/jsonarrayconst/begin/
   iterator begin() const {
-    if (!data_)
-      return iterator();
-    return iterator(data_->createIterator(resources_), resources_);
+    return iterator(impl_.createIterator(), impl_.resources());
   }
 
   // Returns an iterator to the element following the last element of the array.
@@ -36,21 +34,21 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
   }
 
   // Creates an unbound reference.
-  JsonArrayConst() : data_(0), resources_(0) {}
+  JsonArrayConst() {}
 
   // INTERNAL USE ONLY
-  JsonArrayConst(const detail::ArrayData* data,
-                 const detail::ResourceManager* resources)
-      : data_(data), resources_(resources) {}
+  JsonArrayConst(detail::VariantData* data, detail::ResourceManager* resources)
+      : impl_(data, resources) {}
+
+  // INTERNAL USE ONLY
+  JsonArrayConst(const detail::VariantImpl& impl) : impl_(impl) {}
 
   // Returns the element at the specified index.
   // https://arduinojson.org/v7/api/jsonarrayconst/subscript/
   template <typename T,
             detail::enable_if_t<detail::is_integral<T>::value, int> = 0>
   JsonVariantConst operator[](T index) const {
-    return JsonVariantConst(
-        detail::ArrayData::getElement(data_, size_t(index), resources_),
-        resources_);
+    return JsonVariantConst(impl_.getElement(size_t(index)), impl_.resources());
   }
 
   // Returns the element at the specified index.
@@ -65,31 +63,31 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
   }
 
   operator JsonVariantConst() const {
-    return JsonVariantConst(getData(), resources_);
+    return JsonVariantConst(impl_.data(), impl_.resources());
   }
 
   // Returns true if the reference is unbound.
   // https://arduinojson.org/v7/api/jsonarrayconst/isnull/
   bool isNull() const {
-    return data_ == 0;
+    return impl_.isNull();
   }
 
   // Returns true if the reference is bound.
   // https://arduinojson.org/v7/api/jsonarrayconst/isnull/
   operator bool() const {
-    return data_ != 0;
+    return !isNull();
   }
 
   // Returns the depth (nesting level) of the array.
   // https://arduinojson.org/v7/api/jsonarrayconst/nesting/
   size_t nesting() const {
-    return detail::VariantData::nesting(getData(), resources_);
+    return impl_.nesting();
   }
 
   // Returns the number of elements in the array.
   // https://arduinojson.org/v7/api/jsonarrayconst/size/
   size_t size() const {
-    return data_ ? data_->size(resources_) : 0;
+    return impl_.size();
   }
 
   // DEPRECATED: always returns zero
@@ -100,11 +98,10 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
 
  private:
   const detail::VariantData* getData() const {
-    return collectionToVariant(data_);
+    return impl_.data();
   }
 
-  const detail::ArrayData* data_;
-  const detail::ResourceManager* resources_;
+  detail::VariantImpl impl_;
 };
 
 // Compares the content of two arrays.

src/ArduinoJson/Array/JsonArrayIterator.hpp

@@ -30,7 +30,7 @@ class JsonArrayIterator {
 
  public:
   JsonArrayIterator() {}
-  explicit JsonArrayIterator(detail::ArrayData::iterator iterator,
+  explicit JsonArrayIterator(detail::CollectionIterator iterator,
                              detail::ResourceManager* resources)
       : iterator_(iterator), resources_(resources) {}
 
@@ -50,12 +50,12 @@ class JsonArrayIterator {
   }
 
   JsonArrayIterator& operator++() {
-    iterator_.next(resources_);
+    iterator_.move(resources_);
     return *this;
   }
 
  private:
-  detail::ArrayData::iterator iterator_;
+  detail::CollectionIterator iterator_;
   detail::ResourceManager* resources_;
 };
 
@@ -64,8 +64,8 @@ class JsonArrayConstIterator {
 
  public:
   JsonArrayConstIterator() {}
-  explicit JsonArrayConstIterator(detail::ArrayData::iterator iterator,
-                                  const detail::ResourceManager* resources)
+  explicit JsonArrayConstIterator(detail::CollectionIterator iterator,
+                                  detail::ResourceManager* resources)
       : iterator_(iterator), resources_(resources) {}
 
   JsonVariantConst operator*() const {
@@ -84,13 +84,13 @@ class JsonArrayConstIterator {
   }
 
   JsonArrayConstIterator& operator++() {
-    iterator_.next(resources_);
+    iterator_.move(resources_);
     return *this;
   }
 
  private:
-  detail::ArrayData::iterator iterator_;
-  const detail::ResourceManager* resources_;
+  mutable detail::CollectionIterator iterator_;
+  mutable detail::ResourceManager* resources_;
 };
 
 ARDUINOJSON_END_PUBLIC_NAMESPACE

src/ArduinoJson/Collection/CollectionData.hpp

@@ -1,122 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2025, Benoit BLANCHON
-// MIT License
-
-#pragma once
-
-#include <ArduinoJson/Memory/MemoryPool.hpp>
-#include <ArduinoJson/Namespace.hpp>
-#include <ArduinoJson/Polyfills/assert.hpp>
-
-#include <stddef.h>  // size_t
-
-ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
-
-class VariantData;
-class ResourceManager;
-
-class CollectionIterator {
-  friend class CollectionData;
-
- public:
-  CollectionIterator() : slot_(nullptr), currentId_(NULL_SLOT) {}
-
-  void next(const ResourceManager* resources);
-
-  bool done() const {
-    return slot_ == nullptr;
-  }
-
-  bool operator==(const CollectionIterator& other) const {
-    return slot_ == other.slot_;
-  }
-
-  bool operator!=(const CollectionIterator& other) const {
-    return slot_ != other.slot_;
-  }
-
-  VariantData* operator->() {
-    ARDUINOJSON_ASSERT(slot_ != nullptr);
-    return data();
-  }
-
-  VariantData& operator*() {
-    ARDUINOJSON_ASSERT(slot_ != nullptr);
-    return *data();
-  }
-
-  const VariantData& operator*() const {
-    ARDUINOJSON_ASSERT(slot_ != nullptr);
-    return *data();
-  }
-
-  VariantData* data() {
-    return reinterpret_cast<VariantData*>(slot_);
-  }
-
-  const VariantData* data() const {
-    return reinterpret_cast<const VariantData*>(slot_);
-  }
-
- private:
-  CollectionIterator(VariantData* slot, SlotId slotId);
-
-  VariantData* slot_;
-  SlotId currentId_, nextId_;
-};
-
-class CollectionData {
-  SlotId head_ = NULL_SLOT;
-  SlotId tail_ = NULL_SLOT;
-
- public:
-  // Placement new
-  static void* operator new(size_t, void* p) noexcept {
-    return p;
-  }
-
-  static void operator delete(void*, void*) noexcept {}
-
-  using iterator = CollectionIterator;
-
-  iterator createIterator(const ResourceManager* resources) const;
-
-  size_t size(const ResourceManager*) const;
-  size_t nesting(const ResourceManager*) const;
-
-  void clear(ResourceManager* resources);
-
-  static void clear(CollectionData* collection, ResourceManager* resources) {
-    if (!collection)
-      return;
-    collection->clear(resources);
-  }
-
-  SlotId head() const {
-    return head_;
-  }
-
- protected:
-  void appendOne(Slot<VariantData> slot, const ResourceManager* resources);
-  void appendPair(Slot<VariantData> key, Slot<VariantData> value,
-                  const ResourceManager* resources);
-
-  void removeOne(iterator it, ResourceManager* resources);
-  void removePair(iterator it, ResourceManager* resources);
-
- private:
-  Slot<VariantData> getPreviousSlot(VariantData*, const ResourceManager*) const;
-};
-
-inline const VariantData* collectionToVariant(
-    const CollectionData* collection) {
-  const void* data = collection;  // prevent warning cast-align
-  return reinterpret_cast<const VariantData*>(data);
-}
-
-inline VariantData* collectionToVariant(CollectionData* collection) {
-  void* data = collection;  // prevent warning cast-align
-  return reinterpret_cast<VariantData*>(data);
-}
-
-ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Collection/CollectionImpl.hpp

@@ -4,134 +4,144 @@
 
 #pragma once
 
-#include <ArduinoJson/Collection/CollectionData.hpp>
-#include <ArduinoJson/Memory/Alignment.hpp>
-#include <ArduinoJson/Strings/StringAdapters.hpp>
-#include <ArduinoJson/Variant/VariantCompare.hpp>
-#include <ArduinoJson/Variant/VariantData.hpp>
+#include <ArduinoJson/Variant/VariantImpl.hpp>
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
-inline CollectionIterator::CollectionIterator(VariantData* slot, SlotId slotId)
-    : slot_(slot), currentId_(slotId) {
-  nextId_ = slot_ ? slot_->next() : NULL_SLOT;
+inline void CollectionIterator::move(const ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(slot_);
+  auto nextId = slot_->next;
+  slot_ = resources->getVariant(nextId);
+  currentId_ = nextId;
 }
 
-inline void CollectionIterator::next(const ResourceManager* resources) {
-  ARDUINOJSON_ASSERT(currentId_ != NULL_SLOT);
-  slot_ = resources->getVariant(nextId_);
-  currentId_ = nextId_;
-  if (slot_)
-    nextId_ = slot_->next();
+inline VariantImpl::iterator VariantImpl::createIterator(
+    VariantData* data, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->isCollection());
+  ARDUINOJSON_ASSERT(resources != nullptr);
+  auto head = data->content.asCollection.head;
+  return iterator(resources->getVariant(head), head);
 }
 
-inline CollectionData::iterator CollectionData::createIterator(
-    const ResourceManager* resources) const {
-  return iterator(resources->getVariant(head_), head_);
-}
+inline void VariantImpl::addElement(Slot<VariantData> slot, VariantData* data,
+                                    ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->isCollection());
+  ARDUINOJSON_ASSERT(resources != nullptr);
 
-inline void CollectionData::appendOne(Slot<VariantData> slot,
-                                      const ResourceManager* resources) {
-  if (tail_ != NULL_SLOT) {
-    auto tail = resources->getVariant(tail_);
-    tail->setNext(slot.id());
-    tail_ = slot.id();
+  auto coll = &data->content.asCollection;
+
+  if (coll->tail != NULL_SLOT) {
+    auto tail = resources->getVariant(coll->tail);
+    tail->next = slot.id();
+    coll->tail = slot.id();
   } else {
-    head_ = slot.id();
-    tail_ = slot.id();
+    coll->head = slot.id();
+    coll->tail = slot.id();
   }
 }
 
-inline void CollectionData::appendPair(Slot<VariantData> key,
-                                       Slot<VariantData> value,
-                                       const ResourceManager* resources) {
-  key->setNext(value.id());
+inline void VariantImpl::appendPair(Slot<VariantData> key,
+                                    Slot<VariantData> value, VariantData* data,
+                                    ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(resources != nullptr);
 
-  if (tail_ != NULL_SLOT) {
-    auto tail = resources->getVariant(tail_);
-    tail->setNext(key.id());
-    tail_ = value.id();
+  key->next = value.id();
+
+  auto coll = &data->content.asCollection;
+
+  if (coll->tail != NULL_SLOT) {
+    auto tail = resources->getVariant(coll->tail);
+    tail->next = key.id();
+    coll->tail = value.id();
   } else {
-    head_ = key.id();
-    tail_ = value.id();
+    coll->head = key.id();
+    coll->tail = value.id();
   }
 }
 
-inline void CollectionData::clear(ResourceManager* resources) {
-  auto next = head_;
+inline void VariantImpl::empty(VariantData* data, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->isCollection());
+  ARDUINOJSON_ASSERT(resources != nullptr);
+
+  auto coll = &data->content.asCollection;
+
+  auto next = coll->head;
   while (next != NULL_SLOT) {
     auto currId = next;
     auto slot = resources->getVariant(next);
-    next = slot->next();
-    resources->freeVariant({slot, currId});
+    next = slot->next;
+    freeVariant({slot, currId}, resources);
   }
 
-  head_ = NULL_SLOT;
-  tail_ = NULL_SLOT;
+  coll->head = NULL_SLOT;
+  coll->tail = NULL_SLOT;
 }
 
-inline Slot<VariantData> CollectionData::getPreviousSlot(
-    VariantData* target, const ResourceManager* resources) const {
+inline Slot<VariantData> VariantImpl::getPreviousSlot(
+    VariantData* target) const {
+  ARDUINOJSON_ASSERT(data_ != nullptr);
+  ARDUINOJSON_ASSERT(data_->isCollection());
+  ARDUINOJSON_ASSERT(resources_ != nullptr);
+
   auto prev = Slot<VariantData>();
-  auto currentId = head_;
+  auto currentId = data_->content.asCollection.head;
   while (currentId != NULL_SLOT) {
-    auto currentSlot = resources->getVariant(currentId);
+    auto currentSlot = resources_->getVariant(currentId);
     if (currentSlot == target)
       break;
     prev = Slot<VariantData>(currentSlot, currentId);
-    currentId = currentSlot->next();
+    currentId = currentSlot->next;
   }
   return prev;
 }
 
-inline void CollectionData::removeOne(iterator it, ResourceManager* resources) {
+inline void VariantImpl::removeOne(iterator it) {
   if (it.done())
     return;
   auto curr = it.slot_;
-  auto prev = getPreviousSlot(curr, resources);
-  auto next = curr->next();
+  auto prev = getPreviousSlot(curr);
+  auto next = curr->next;
+  auto coll = &data_->content.asCollection;
   if (prev)
-    prev->setNext(next);
+    prev->next = next;
   else
-    head_ = next;
+    coll->head = next;
   if (next == NULL_SLOT)
-    tail_ = prev.id();
-  resources->freeVariant({it.slot_, it.currentId_});
+    coll->tail = prev.id();
+  freeVariant({it.slot_, it.currentId_}, resources_);
 }
 
-inline void CollectionData::removePair(ObjectData::iterator it,
-                                       ResourceManager* resources) {
+inline void VariantImpl::removePair(iterator it) {
   if (it.done())
     return;
 
   auto keySlot = it.slot_;
 
-  auto valueId = it.nextId_;
-  auto valueSlot = resources->getVariant(valueId);
+  auto valueId = keySlot->next;
+  auto valueSlot = resources_->getVariant(valueId);
 
   // remove value slot
-  keySlot->setNext(valueSlot->next());
-  resources->freeVariant({valueSlot, valueId});
+  keySlot->next = valueSlot->next;
+  freeVariant({valueSlot, valueId}, resources_);
 
   // remove key slot
-  removeOne(it, resources);
+  removeOne(it);
 }
 
-inline size_t CollectionData::nesting(const ResourceManager* resources) const {
+inline size_t VariantImpl::nesting() const {
+  if (!data_ || !data_->isCollection())
+    return 0;
   size_t maxChildNesting = 0;
-  for (auto it = createIterator(resources); !it.done(); it.next(resources)) {
-    size_t childNesting = it->nesting(resources);
+  for (auto it = createIterator(); !it.done(); it.move(resources_)) {
+    size_t childNesting = VariantImpl(it.data(), resources_).nesting();
     if (childNesting > maxChildNesting)
       maxChildNesting = childNesting;
   }
   return maxChildNesting + 1;
 }
 
-inline size_t CollectionData::size(const ResourceManager* resources) const {
-  size_t count = 0;
-  for (auto it = createIterator(resources); !it.done(); it.next(resources))
-    count++;
-  return count;
-}
-
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Collection/CollectionIterator.hpp

@@ -0,0 +1,68 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Namespace.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
+
+#include <stddef.h>  // size_t
+
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+
+struct VariantData;
+class ResourceManager;
+
+class CollectionIterator {
+  friend class VariantImpl;
+
+ public:
+  CollectionIterator() : slot_(nullptr), currentId_(NULL_SLOT) {}
+
+  void move(const ResourceManager* resources);
+
+  bool done() const {
+    return slot_ == nullptr;
+  }
+
+  bool operator==(const CollectionIterator& other) const {
+    return slot_ == other.slot_;
+  }
+
+  bool operator!=(const CollectionIterator& other) const {
+    return slot_ != other.slot_;
+  }
+
+  VariantData* operator->() {
+    ARDUINOJSON_ASSERT(slot_ != nullptr);
+    return data();
+  }
+
+  VariantData& operator*() {
+    ARDUINOJSON_ASSERT(slot_ != nullptr);
+    return *data();
+  }
+
+  const VariantData& operator*() const {
+    ARDUINOJSON_ASSERT(slot_ != nullptr);
+    return *data();
+  }
+
+  VariantData* data() {
+    return slot_;
+  }
+
+  const VariantData* data() const {
+    return slot_;
+  }
+
+ private:
+  CollectionIterator(VariantData* slot, SlotId slotId)
+      : slot_(slot), currentId_(slotId) {}
+
+  VariantData* slot_;
+  SlotId currentId_;
+};
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Configuration.hpp

@@ -274,9 +274,9 @@
 #endif
 
 #if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_DOUBLE
-#  define ARDUINOJSON_USE_EXTENSIONS 1
+#  define ARDUINOJSON_USE_8_BYTE_POOL 1
 #else
-#  define ARDUINOJSON_USE_EXTENSIONS 0
+#  define ARDUINOJSON_USE_8_BYTE_POOL 0
 #endif
 
 #if defined(nullptr)

src/ArduinoJson/Deserialization/deserialize.hpp

@@ -50,7 +50,7 @@ DeserializationError doDeserialize(TDestination&& dst, TReader reader,
   auto resources = VariantAttorney::getResourceManager(dst);
   dst.clear();
   auto err = TDeserializer<TReader>(resources, reader)
-                 .parse(*data, options.filter, options.nestingLimit);
+                 .parse(data, options.filter, options.nestingLimit);
   shrinkJsonDocument(dst);
   return err;
 }

src/ArduinoJson/Document/JsonDocument.hpp

@@ -11,7 +11,6 @@
 #include <ArduinoJson/Object/MemberProxy.hpp>
 #include <ArduinoJson/Polyfills/utility.hpp>
 #include <ArduinoJson/Variant/JsonVariantConst.hpp>
-#include <ArduinoJson/Variant/VariantTo.hpp>
 
 ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
 
@@ -88,7 +87,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   // https://arduinojson.org/v7/api/jsondocument/clear/
   void clear() {
     resources_.clear();
-    data_.reset();
+    data_.type = detail::VariantType::Null;
   }
 
   // Returns true if the root is of the specified type.
@@ -120,13 +119,13 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   // Returns the depth (nesting level) of the array.
   // https://arduinojson.org/v7/api/jsondocument/nesting/
   size_t nesting() const {
-    return data_.nesting(&resources_);
+    return getVariantImpl().nesting();
   }
 
   // Returns the number of elements in the root array or object.
   // https://arduinojson.org/v7/api/jsondocument/size/
   size_t size() const {
-    return data_.size(&resources_);
+    return getVariantImpl().size();
   }
 
   // Copies the specified document.
@@ -146,18 +145,38 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
 
   // Replaces the root with the specified value.
   // https://arduinojson.org/v7/api/jsondocument/set/
-  template <typename TChar,
-            detail::enable_if_t<!detail::is_const<TChar>::value, int> = 0>
+  template <typename TChar>
   bool set(TChar* src) {
     return to<JsonVariant>().set(src);
   }
 
-  // Clears the document and converts it to the specified type.
+  // Sets the document to an empty array.
   // https://arduinojson.org/v7/api/jsondocument/to/
-  template <typename T>
-  typename detail::VariantTo<T>::type to() {
+  template <typename T,
+            detail::enable_if_t<detail::is_same<T, JsonArray>::value, int> = 0>
+  JsonArray to() {
     clear();
-    return getVariant().template to<T>();
+    data_.toArray();
+    return JsonArray(&data_, &resources_);
+  }
+
+  // Sets the document to an empty object.
+  // https://arduinojson.org/v7/api/jsondocument/to/
+  template <typename T,
+            detail::enable_if_t<detail::is_same<T, JsonObject>::value, int> = 0>
+  JsonObject to() {
+    clear();
+    data_.toObject();
+    return JsonObject(&data_, &resources_);
+  }
+
+  // Sets the document to null.
+  // https://arduinojson.org/v7/api/jsondocument/to/
+  template <typename T, detail::enable_if_t<
+                            detail::is_same<T, JsonVariant>::value, int> = 0>
+  JsonVariant to() {
+    clear();
+    return JsonVariant(&data_, &resources_);
   }
 
   // DEPRECATED: use obj["key"].is<T>() instead
@@ -165,7 +184,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   template <typename TChar>
   ARDUINOJSON_DEPRECATED("use doc[\"key\"].is<T>() instead")
   bool containsKey(TChar* key) const {
-    return data_.getMember(detail::adaptString(key), &resources_) != 0;
+    return getVariantImpl().getMember(detail::adaptString(key)) != 0;
   }
 
   // DEPRECATED: use obj[key].is<T>() instead
@@ -174,7 +193,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   ARDUINOJSON_DEPRECATED("use doc[key].is<T>() instead")
   bool containsKey(const TString& key) const {
-    return data_.getMember(detail::adaptString(key), &resources_) != 0;
+    return getVariantImpl().getMember(detail::adaptString(key)) != 0;
   }
 
   // DEPRECATED: use obj[key].is<T>() instead
@@ -198,9 +217,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   // Gets or sets a root object's member.
   // https://arduinojson.org/v7/api/jsondocument/subscript/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   detail::MemberProxy<JsonDocument&, detail::AdaptedString<TChar*>> operator[](
       TChar* key) {
     return {*this, detail::adaptString(key)};
@@ -212,18 +229,16 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   JsonVariantConst operator[](const TString& key) const {
     return JsonVariantConst(
-        data_.getMember(detail::adaptString(key), &resources_), &resources_);
+        getVariantImpl().getMember(detail::adaptString(key)), &resources_);
   }
 
   // Gets a root object's member.
   // https://arduinojson.org/v7/api/jsondocument/subscript/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   JsonVariantConst operator[](TChar* key) const {
     return JsonVariantConst(
-        data_.getMember(detail::adaptString(key), &resources_), &resources_);
+        getVariantImpl().getMember(detail::adaptString(key)), &resources_);
   }
 
   // Gets or sets a root array's element.
@@ -237,7 +252,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   // Gets a root array's member.
   // https://arduinojson.org/v7/api/jsondocument/subscript/
   JsonVariantConst operator[](size_t index) const {
-    return JsonVariantConst(data_.getElement(index, &resources_), &resources_);
+    return JsonVariantConst(getVariantImpl().getElement(index), &resources_);
   }
 
   // Gets or sets a root object's member.
@@ -267,22 +282,21 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   template <typename T, detail::enable_if_t<
                             detail::is_same<T, JsonVariant>::value, int> = 0>
   JsonVariant add() {
-    return JsonVariant(data_.addElement(&resources_), &resources_);
+    return getOrCreateArray().add<T>();
   }
 
   // Appends a value to the root array.
   // https://arduinojson.org/v7/api/jsondocument/add/
   template <typename TValue>
   bool add(const TValue& value) {
-    return data_.addValue(value, &resources_);
+    return getOrCreateArray().add(value);
   }
 
   // Appends a value to the root array.
   // https://arduinojson.org/v7/api/jsondocument/add/
-  template <typename TChar,
-            detail::enable_if_t<!detail::is_const<TChar>::value, int> = 0>
+  template <typename TChar>
   bool add(TChar* value) {
-    return data_.addValue(value, &resources_);
+    return getOrCreateArray().add(value);
   }
 
   // Removes an element of the root array.
@@ -290,19 +304,15 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   template <typename T,
             detail::enable_if_t<detail::is_integral<T>::value, int> = 0>
   void remove(T index) {
-    detail::VariantData::removeElement(getData(), size_t(index),
-                                       getResourceManager());
+    getVariantImpl().removeElement(size_t(index));
   }
 
   // Removes a member of the root object.
   // https://arduinojson.org/v7/api/jsondocument/remove/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   void remove(TChar* key) {
-    detail::VariantData::removeMember(getData(), detail::adaptString(key),
-                                      getResourceManager());
+    getVariantImpl().removeMember(detail::adaptString(key));
   }
 
   // Removes a member of the root object.
@@ -310,8 +320,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   template <typename TString,
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   void remove(const TString& key) {
-    detail::VariantData::removeMember(getData(), detail::adaptString(key),
-                                      getResourceManager());
+    getVariantImpl().removeMember(detail::adaptString(key));
   }
 
   // Removes a member of the root object or an element of the root array.
@@ -391,6 +400,16 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   }
 
  private:
+  detail::VariantImpl getVariantImpl() const {
+    return detail::VariantImpl(&data_, &resources_);
+  }
+
+  JsonArray getOrCreateArray() const {
+    if (data_.type == detail::VariantType::Null)
+      data_.toArray();
+    return JsonArray(&data_, &resources_);
+  }
+
   JsonVariant getVariant() {
     return JsonVariant(&data_, &resources_);
   }
@@ -415,12 +434,12 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
     return &data_;
   }
 
-  detail::ResourceManager resources_;
-  detail::VariantData data_;
+  mutable detail::ResourceManager resources_;
+  mutable detail::VariantData data_;
 };
 
-inline void convertToJson(const JsonDocument& src, JsonVariant dst) {
-  dst.set(src.as<JsonVariantConst>());
+inline bool convertToJson(const JsonDocument& src, JsonVariant dst) {
+  return dst.set(src.as<JsonVariantConst>());
 }
 
 ARDUINOJSON_END_PUBLIC_NAMESPACE

src/ArduinoJson/Json/JsonDeserializer.hpp

@@ -28,13 +28,13 @@ class JsonDeserializer {
         resources_(resources) {}
 
   template <typename TFilter>
-  DeserializationError parse(VariantData& variant, TFilter filter,
+  DeserializationError parse(VariantData* variant, TFilter filter,
                              DeserializationOption::NestingLimit nestingLimit) {
     DeserializationError::Code err;
 
     err = parseVariant(variant, filter, nestingLimit);
 
-    if (!err && latch_.last() != 0 && variant.isFloat()) {
+    if (!err && latch_.last() != 0 && variant->isFloat()) {
       // We don't detect trailing characters earlier, so we need to check now
       return DeserializationError::InvalidInput;
     }
@@ -60,7 +60,7 @@ class JsonDeserializer {
 
   template <typename TFilter>
   DeserializationError::Code parseVariant(
-      VariantData& variant, TFilter filter,
+      VariantData* variant, TFilter filter,
       DeserializationOption::NestingLimit nestingLimit) {
     DeserializationError::Code err;
 
@@ -71,13 +71,13 @@ class JsonDeserializer {
     switch (current()) {
       case '[':
         if (filter.allowArray())
-          return parseArray(variant.toArray(), filter, nestingLimit);
+          return parseArray(variant, filter, nestingLimit);
         else
           return skipArray(nestingLimit);
 
       case '{':
         if (filter.allowObject())
-          return parseObject(variant.toObject(), filter, nestingLimit);
+          return parseObject(variant, filter, nestingLimit);
         else
           return skipObject(nestingLimit);
 
@@ -90,12 +90,12 @@ class JsonDeserializer {
 
       case 't':
         if (filter.allowValue())
-          variant.setBoolean(true);
+          variant->setBoolean(true);
         return skipKeyword("true");
 
       case 'f':
         if (filter.allowValue())
-          variant.setBoolean(false);
+          variant->setBoolean(false);
         return skipKeyword("false");
 
       case 'n':
@@ -146,10 +146,12 @@ class JsonDeserializer {
 
   template <typename TFilter>
   DeserializationError::Code parseArray(
-      ArrayData& array, TFilter filter,
+      VariantData* array, TFilter filter,
       DeserializationOption::NestingLimit nestingLimit) {
     DeserializationError::Code err;
 
+    array->toArray();
+
     if (nestingLimit.reached())
       return DeserializationError::TooDeep;
 
@@ -172,12 +174,12 @@ class JsonDeserializer {
     for (;;) {
       if (elementFilter.allow()) {
         // Allocate slot in array
-        VariantData* value = array.addElement(resources_);
+        VariantData* value = VariantImpl::addNewElement(array, resources_);
         if (!value)
           return DeserializationError::NoMemory;
 
         // 1 - Parse value
-        err = parseVariant(*value, elementFilter, nestingLimit.decrement());
+        err = parseVariant(value, elementFilter, nestingLimit.decrement());
         if (err)
           return err;
       } else {
@@ -232,10 +234,12 @@ class JsonDeserializer {
 
   template <typename TFilter>
   DeserializationError::Code parseObject(
-      ObjectData& object, TFilter filter,
+      VariantData* object, TFilter filter,
       DeserializationOption::NestingLimit nestingLimit) {
     DeserializationError::Code err;
 
+    object->toObject();
+
     if (nestingLimit.reached())
       return DeserializationError::TooDeep;
 
@@ -273,19 +277,20 @@ class JsonDeserializer {
       TFilter memberFilter = filter[key];
 
       if (memberFilter.allow()) {
-        auto member = object.getMember(adaptString(key), resources_);
+        auto member =
+            VariantImpl::getMember(adaptString(key), object, resources_);
         if (!member) {
-          auto keyVariant = object.addPair(&member, resources_);
+          auto keyVariant = VariantImpl::addPair(&member, object, resources_);
           if (!keyVariant)
             return DeserializationError::NoMemory;
 
           stringBuilder_.save(keyVariant);
         } else {
-          member->clear(resources_);
+          VariantImpl::clear(member, resources_);
         }
 
         // Parse value
-        err = parseVariant(*member, memberFilter, nestingLimit.decrement());
+        err = parseVariant(member, memberFilter, nestingLimit.decrement());
         if (err)
           return err;
       } else {
@@ -379,7 +384,7 @@ class JsonDeserializer {
     }
   }
 
-  DeserializationError::Code parseStringValue(VariantData& variant) {
+  DeserializationError::Code parseStringValue(VariantData* variant) {
     DeserializationError::Code err;
 
     stringBuilder_.startString();
@@ -388,7 +393,7 @@ class JsonDeserializer {
     if (err)
       return err;
 
-    stringBuilder_.save(&variant);
+    stringBuilder_.save(variant);
 
     return DeserializationError::Ok;
   }
@@ -504,7 +509,7 @@ class JsonDeserializer {
     return DeserializationError::Ok;
   }
 
-  DeserializationError::Code parseNumericValue(VariantData& result) {
+  DeserializationError::Code parseNumericValue(VariantData* result) {
     uint8_t n = 0;
 
     char c = current();
@@ -518,26 +523,28 @@ class JsonDeserializer {
     auto number = parseNumber(buffer_);
     switch (number.type()) {
       case NumberType::UnsignedInteger:
-        if (result.setInteger(number.asUnsignedInteger(), resources_))
+        if (VariantImpl::setInteger(number.asUnsignedInteger(), result,
+                                    resources_))
           return DeserializationError::Ok;
         else
           return DeserializationError::NoMemory;
 
       case NumberType::SignedInteger:
-        if (result.setInteger(number.asSignedInteger(), resources_))
+        if (VariantImpl::setInteger(number.asSignedInteger(), result,
+                                    resources_))
           return DeserializationError::Ok;
         else
           return DeserializationError::NoMemory;
 
       case NumberType::Float:
-        if (result.setFloat(number.asFloat(), resources_))
+        if (VariantImpl::setFloat(number.asFloat(), result, resources_))
           return DeserializationError::Ok;
         else
           return DeserializationError::NoMemory;
 
 #if ARDUINOJSON_USE_DOUBLE
       case NumberType::Double:
-        if (result.setFloat(number.asDouble(), resources_))
+        if (VariantImpl::setFloat(number.asDouble(), result, resources_))
           return DeserializationError::Ok;
         else
           return DeserializationError::NoMemory;

src/ArduinoJson/Json/JsonSerializer.hpp

@@ -16,20 +16,23 @@ class JsonSerializer : public VariantDataVisitor<size_t> {
  public:
   static const bool producesText = true;
 
-  JsonSerializer(TWriter writer, const ResourceManager* resources)
+  JsonSerializer(TWriter writer, ResourceManager* resources)
       : formatter_(writer), resources_(resources) {}
 
-  size_t visit(const ArrayData& array) {
+  size_t visitArray(VariantData* array) {
+    ARDUINOJSON_ASSERT(array != nullptr);
+    ARDUINOJSON_ASSERT(array->isArray());
+
     write('[');
 
-    auto slotId = array.head();
+    auto slotId = array->content.asCollection.head;
 
     while (slotId != NULL_SLOT) {
       auto slot = resources_->getVariant(slotId);
 
-      slot->accept(*this, resources_);
+      VariantImpl::accept(*this, slot, resources_);
 
-      slotId = slot->next();
+      slotId = slot->next;
 
       if (slotId != NULL_SLOT)
         write(',');
@@ -39,18 +42,21 @@ class JsonSerializer : public VariantDataVisitor<size_t> {
     return bytesWritten();
   }
 
-  size_t visit(const ObjectData& object) {
+  size_t visitObject(VariantData* object) {
+    ARDUINOJSON_ASSERT(object != nullptr);
+    ARDUINOJSON_ASSERT(object->isObject());
+
     write('{');
 
-    auto slotId = object.head();
+    auto slotId = object->content.asCollection.head;
 
     bool isKey = true;
 
     while (slotId != NULL_SLOT) {
       auto slot = resources_->getVariant(slotId);
-      slot->accept(*this, resources_);
+      VariantImpl::accept(*this, slot, resources_);
 
-      slotId = slot->next();
+      slotId = slot->next;
 
       if (slotId != NULL_SLOT)
         write(isKey ? ':' : ',');
@@ -120,7 +126,7 @@ class JsonSerializer : public VariantDataVisitor<size_t> {
   TextFormatter<TWriter> formatter_;
 
  protected:
-  const ResourceManager* resources_;
+  ResourceManager* resources_;
 };
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Json/PrettyJsonSerializer.hpp

@@ -16,20 +16,24 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
   using base = JsonSerializer<TWriter>;
 
  public:
-  PrettyJsonSerializer(TWriter writer, const ResourceManager* resources)
+  PrettyJsonSerializer(TWriter writer, ResourceManager* resources)
       : base(writer, resources), nesting_(0) {}
 
-  size_t visit(const ArrayData& array) {
-    auto it = array.createIterator(base::resources_);
-    if (!it.done()) {
+  size_t visitArray(VariantData* array) {
+    ARDUINOJSON_ASSERT(array != nullptr);
+    ARDUINOJSON_ASSERT(array->isArray());
+
+    auto slotId = array->content.asCollection.head;
+    if (slotId != NULL_SLOT) {
       base::write("[\r\n");
       nesting_++;
-      while (!it.done()) {
+      while (slotId != NULL_SLOT) {
         indent();
-        it->accept(*this, base::resources_);
+        auto slot = base::resources_->getVariant(slotId);
+        VariantImpl::accept(*this, slot, base::resources_);
 
-        it.next(base::resources_);
-        base::write(it.done() ? "\r\n" : ",\r\n");
+        slotId = slot->next;
+        base::write(slotId == NULL_SLOT ? "\r\n" : ",\r\n");
       }
       nesting_--;
       indent();
@@ -40,21 +44,25 @@ class PrettyJsonSerializer : public JsonSerializer<TWriter> {
     return this->bytesWritten();
   }
 
-  size_t visit(const ObjectData& object) {
-    auto it = object.createIterator(base::resources_);
-    if (!it.done()) {
+  size_t visitObject(VariantData* object) {
+    ARDUINOJSON_ASSERT(object != nullptr);
+    ARDUINOJSON_ASSERT(object->isObject());
+
+    auto slotId = object->content.asCollection.head;
+    if (slotId != NULL_SLOT) {
       base::write("{\r\n");
       nesting_++;
       bool isKey = true;
-      while (!it.done()) {
+      while (slotId != NULL_SLOT) {
         if (isKey)
           indent();
-        it->accept(*this, base::resources_);
-        it.next(base::resources_);
+        auto slot = base::resources_->getVariant(slotId);
+        VariantImpl::accept(*this, slot, base::resources_);
+        slotId = slot->next;
         if (isKey)
           base::write(": ");
         else
-          base::write(it.done() ? "\r\n" : ",\r\n");
+          base::write(slotId == NULL_SLOT ? "\r\n" : ",\r\n");
         isKey = !isKey;
       }
       nesting_--;

src/ArduinoJson/Json/TextFormatter.hpp

@@ -66,13 +66,16 @@ class TextFormatter {
 
   template <typename T>
   void writeFloat(T value) {
-    writeFloat(JsonFloat(value), sizeof(T) >= 8 ? 9 : 6);
+    writeFloat(JsonFloat(value), sizeof(T) >= 8 ? 9 : 7);
   }
 
   void writeFloat(JsonFloat value, int8_t decimalPlaces) {
     if (isnan(value))
       return writeRaw(ARDUINOJSON_ENABLE_NAN ? "NaN" : "null");
 
+    if (!value)
+      return writeRaw("0");
+
 #if ARDUINOJSON_ENABLE_INFINITY
     if (value < 0.0) {
       writeRaw('-');
@@ -93,9 +96,28 @@ class TextFormatter {
 
     auto parts = decomposeFloat(value, decimalPlaces);
 
-    writeInteger(parts.integral);
-    if (parts.decimalPlaces)
-      writeDecimals(parts.decimal, parts.decimalPlaces);
+    // buffer should be big enough for all digits and the dot
+    char buffer[32];
+    char* end = buffer + sizeof(buffer);
+    char* begin = end;
+
+    // write the string in reverse order
+    while (parts.mantissa != 0 || parts.pointIndex > 0) {
+      *--begin = char(parts.mantissa % 10 + '0');
+      parts.mantissa /= 10;
+      if (parts.pointIndex == 1) {
+        *--begin = '.';
+      }
+      parts.pointIndex--;
+    }
+
+    // Avoid a leading dot
+    if (parts.pointIndex == 0) {
+      *--begin = '0';
+    }
+
+    // and dump it in the right order
+    writeRaw(begin, end);
 
     if (parts.exponent) {
       writeRaw('e');
@@ -132,23 +154,6 @@ class TextFormatter {
     writeRaw(begin, end);
   }
 
-  void writeDecimals(uint32_t value, int8_t width) {
-    // buffer should be big enough for all digits and the dot
-    char buffer[16];
-    char* end = buffer + sizeof(buffer);
-    char* begin = end;
-
-    // write the string in reverse order
-    while (width--) {
-      *--begin = char(value % 10 + '0');
-      value /= 10;
-    }
-    *--begin = '.';
-
-    // and dump it in the right order
-    writeRaw(begin, end);
-  }
-
   void writeRaw(const char* s) {
     writer_.write(reinterpret_cast<const uint8_t*>(s), strlen(s));
   }

src/ArduinoJson/Memory/ResourceManager.hpp

@@ -14,26 +14,19 @@
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
-class VariantData;
 class VariantWithId;
 
 class ResourceManager {
-  union SlotData {
-    VariantData variant;
-#if ARDUINOJSON_USE_EXTENSIONS
-    VariantExtension extension;
-#endif
-  };
-
  public:
-  constexpr static size_t slotSize = sizeof(SlotData);
-
   ResourceManager(Allocator* allocator = DefaultAllocator::instance())
       : allocator_(allocator), overflowed_(false) {}
 
   ~ResourceManager() {
     stringPool_.clear(allocator_);
     variantPools_.clear(allocator_);
+#if ARDUINOJSON_USE_8_BYTE_POOL
+    eightBytePools_.clear(allocator_);
+#endif
   }
 
   ResourceManager(const ResourceManager&) = delete;
@@ -42,6 +35,9 @@ class ResourceManager {
   friend void swap(ResourceManager& a, ResourceManager& b) {
     swap(a.stringPool_, b.stringPool_);
     swap(a.variantPools_, b.variantPools_);
+#if ARDUINOJSON_USE_8_BYTE_POOL
+    swap(a.eightBytePools_, b.eightBytePools_);
+#endif
     swap_(a.allocator_, b.allocator_);
     swap_(a.overflowed_, b.overflowed_);
   }
@@ -58,14 +54,43 @@ class ResourceManager {
     return overflowed_;
   }
 
-  Slot<VariantData> allocVariant();
-  void freeVariant(Slot<VariantData> slot);
-  VariantData* getVariant(SlotId id) const;
+  Slot<VariantData> allocVariant() {
+    auto slot = variantPools_.allocSlot(allocator_);
+    if (!slot) {
+      overflowed_ = true;
+      return {};
+    }
+    new (slot.ptr()) VariantData();
+    return slot;
+  }
 
-#if ARDUINOJSON_USE_EXTENSIONS
-  Slot<VariantExtension> allocExtension();
-  void freeExtension(SlotId slot);
-  VariantExtension* getExtension(SlotId id) const;
+  void freeVariant(Slot<VariantData> slot) {
+    ARDUINOJSON_ASSERT(slot->type == VariantType::Null);
+    variantPools_.freeSlot(slot);
+  }
+
+  VariantData* getVariant(SlotId id) const {
+    return reinterpret_cast<VariantData*>(variantPools_.getSlot(id));
+  }
+
+#if ARDUINOJSON_USE_8_BYTE_POOL
+  Slot<EightByteValue> allocEightByte() {
+    auto slot = eightBytePools_.allocSlot(allocator_);
+    if (!slot) {
+      overflowed_ = true;
+      return {};
+    }
+    return slot;
+  }
+
+  void freeEightByte(SlotId id) {
+    auto p = getEightByte(id);
+    eightBytePools_.freeSlot({p, id});
+  }
+
+  EightByteValue* getEightByte(SlotId id) const {
+    return eightBytePools_.getSlot(id);
+  }
 #endif
 
   template <typename TAdaptedString>
@@ -115,17 +140,26 @@ class ResourceManager {
     variantPools_.clear(allocator_);
     overflowed_ = false;
     stringPool_.clear(allocator_);
+#if ARDUINOJSON_USE_8_BYTE_POOL
+    eightBytePools_.clear(allocator_);
+#endif
   }
 
   void shrinkToFit() {
     variantPools_.shrinkToFit(allocator_);
+#if ARDUINOJSON_USE_8_BYTE_POOL
+    eightBytePools_.shrinkToFit(allocator_);
+#endif
   }
 
  private:
   Allocator* allocator_;
   bool overflowed_;
   StringPool stringPool_;
-  MemoryPoolList<SlotData> variantPools_;
+  MemoryPoolList<VariantData> variantPools_;
+#if ARDUINOJSON_USE_8_BYTE_POOL
+  MemoryPoolList<EightByteValue> eightBytePools_;
+#endif
 };
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Memory/ResourceManagerImpl.hpp

@@ -1,52 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2025, Benoit BLANCHON
-// MIT License
-
-#pragma once
-
-#include <ArduinoJson/Collection/CollectionData.hpp>
-#include <ArduinoJson/Memory/ResourceManager.hpp>
-#include <ArduinoJson/Polyfills/alias_cast.hpp>
-#include <ArduinoJson/Variant/VariantData.hpp>
-
-ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
-
-inline Slot<VariantData> ResourceManager::allocVariant() {
-  auto p = variantPools_.allocSlot(allocator_);
-  if (!p) {
-    overflowed_ = true;
-    return {};
-  }
-  return {new (&p->variant) VariantData, p.id()};
-}
-
-inline void ResourceManager::freeVariant(Slot<VariantData> variant) {
-  variant->clear(this);
-  variantPools_.freeSlot({alias_cast<SlotData*>(variant.ptr()), variant.id()});
-}
-
-inline VariantData* ResourceManager::getVariant(SlotId id) const {
-  return reinterpret_cast<VariantData*>(variantPools_.getSlot(id));
-}
-
-#if ARDUINOJSON_USE_EXTENSIONS
-inline Slot<VariantExtension> ResourceManager::allocExtension() {
-  auto p = variantPools_.allocSlot(allocator_);
-  if (!p) {
-    overflowed_ = true;
-    return {};
-  }
-  return {&p->extension, p.id()};
-}
-
-inline void ResourceManager::freeExtension(SlotId id) {
-  auto p = getExtension(id);
-  variantPools_.freeSlot({reinterpret_cast<SlotData*>(p), id});
-}
-
-inline VariantExtension* ResourceManager::getExtension(SlotId id) const {
-  return &variantPools_.getSlot(id)->extension;
-}
-#endif
-
-ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Memory/StringBuffer.hpp

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <ArduinoJson/Memory/ResourceManager.hpp>
+#include <ArduinoJson/Strings/JsonString.hpp>
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
@@ -43,7 +44,7 @@ class StringBuffer {
     if (isTinyString(s, size_))
       data->setTinyString(adaptString(s, size_));
     else
-      data->setOwnedString(commitStringNode());
+      data->setLongString(commitStringNode());
   }
 
   void saveRaw(VariantData* data) {

src/ArduinoJson/Memory/StringBuilder.hpp

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <ArduinoJson/Memory/ResourceManager.hpp>
+#include <ArduinoJson/Strings/JsonString.hpp>
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
@@ -45,7 +46,7 @@ class StringBuilder {
     } else {
       node->references++;
     }
-    variant->setOwnedString(node);
+    variant->setLongString(node);
   }
 
   void append(const char* s) {

src/ArduinoJson/MsgPack/MsgPackBinary.hpp

@@ -24,45 +24,48 @@ class MsgPackBinary {
 
 template <>
 struct Converter<MsgPackBinary> : private detail::VariantAttorney {
-  static void toJson(MsgPackBinary src, JsonVariant dst) {
+  static bool toJson(MsgPackBinary src, JsonVariant dst) {
     auto data = VariantAttorney::getData(dst);
     if (!data)
-      return;
+      return false;
+
     auto resources = getResourceManager(dst);
-    data->clear(resources);
-    if (src.data()) {
-      size_t headerSize = src.size() >= 0x10000 ? 5
-                          : src.size() >= 0x100 ? 3
-                                                : 2;
-      auto str = resources->createString(src.size() + headerSize);
-      if (str) {
-        resources->saveString(str);
-        auto ptr = reinterpret_cast<uint8_t*>(str->data);
-        switch (headerSize) {
-          case 2:
-            ptr[0] = uint8_t(0xc4);
-            ptr[1] = uint8_t(src.size() & 0xff);
-            break;
-          case 3:
-            ptr[0] = uint8_t(0xc5);
-            ptr[1] = uint8_t(src.size() >> 8 & 0xff);
-            ptr[2] = uint8_t(src.size() & 0xff);
-            break;
-          case 5:
-            ptr[0] = uint8_t(0xc6);
-            ptr[1] = uint8_t(src.size() >> 24 & 0xff);
-            ptr[2] = uint8_t(src.size() >> 16 & 0xff);
-            ptr[3] = uint8_t(src.size() >> 8 & 0xff);
-            ptr[4] = uint8_t(src.size() & 0xff);
-            break;
-          default:
-            ARDUINOJSON_ASSERT(false);
-        }
-        memcpy(ptr + headerSize, src.data(), src.size());
-        data->setRawString(str);
-        return;
-      }
+    detail::VariantImpl::clear(data, resources);
+
+    if (!src.data())
+      return true;
+
+    size_t headerSize = src.size() >= 0x10000 ? 5 : src.size() >= 0x100 ? 3 : 2;
+
+    auto str = resources->createString(src.size() + headerSize);
+    if (!str)
+      return false;
+
+    resources->saveString(str);
+    auto ptr = reinterpret_cast<uint8_t*>(str->data);
+    switch (headerSize) {
+      case 2:
+        ptr[0] = uint8_t(0xc4);
+        ptr[1] = uint8_t(src.size() & 0xff);
+        break;
+      case 3:
+        ptr[0] = uint8_t(0xc5);
+        ptr[1] = uint8_t(src.size() >> 8 & 0xff);
+        ptr[2] = uint8_t(src.size() & 0xff);
+        break;
+      case 5:
+        ptr[0] = uint8_t(0xc6);
+        ptr[1] = uint8_t(src.size() >> 24 & 0xff);
+        ptr[2] = uint8_t(src.size() >> 16 & 0xff);
+        ptr[3] = uint8_t(src.size() >> 8 & 0xff);
+        ptr[4] = uint8_t(src.size() & 0xff);
+        break;
+      default:
+        ARDUINOJSON_ASSERT(false);
     }
+    memcpy(ptr + headerSize, src.data(), src.size());
+    data->setRawString(str);
+    return true;
   }
 
   static MsgPackBinary fromJson(JsonVariantConst src) {

src/ArduinoJson/MsgPack/MsgPackDeserializer.hpp

@@ -24,10 +24,10 @@ class MsgPackDeserializer {
         foundSomething_(false) {}
 
   template <typename TFilter>
-  DeserializationError parse(VariantData& variant, TFilter filter,
+  DeserializationError parse(VariantData* variant, TFilter filter,
                              DeserializationOption::NestingLimit nestingLimit) {
     DeserializationError::Code err;
-    err = parseVariant(&variant, filter, nestingLimit);
+    err = parseVariant(variant, filter, nestingLimit);
     return foundSomething_ ? err : DeserializationError::EmptyInput;
   }
 
@@ -91,7 +91,7 @@ class MsgPackDeserializer {
 
     if (code <= 0x7f || code >= 0xe0) {  // fixint
       if (allowValue)
-        variant->setInteger(static_cast<int8_t>(code), resources_);
+        VariantImpl::setInteger(static_cast<int8_t>(code), variant, resources_);
       return DeserializationError::Ok;
     }
 
@@ -231,14 +231,14 @@ class MsgPackDeserializer {
     if (isSigned) {
       auto truncatedValue = static_cast<JsonInteger>(signedValue);
       if (truncatedValue == signedValue) {
-        if (!variant->setInteger(truncatedValue, resources_))
+        if (!VariantImpl::setInteger(truncatedValue, variant, resources_))
           return DeserializationError::NoMemory;
       }
       // else set null on overflow
     } else {
       auto truncatedValue = static_cast<JsonUInt>(unsignedValue);
       if (truncatedValue == unsignedValue)
-        if (!variant->setInteger(truncatedValue, resources_))
+        if (!VariantImpl::setInteger(truncatedValue, variant, resources_))
           return DeserializationError::NoMemory;
       // else set null on overflow
     }
@@ -257,7 +257,7 @@ class MsgPackDeserializer {
       return err;
 
     fixEndianness(value);
-    variant->setFloat(value, resources_);
+    VariantImpl::setFloat(value, variant, resources_);
 
     return DeserializationError::Ok;
   }
@@ -273,7 +273,7 @@ class MsgPackDeserializer {
       return err;
 
     fixEndianness(value);
-    if (variant->setFloat(value, resources_))
+    if (VariantImpl::setFloat(value, variant, resources_))
       return DeserializationError::Ok;
     else
       return DeserializationError::NoMemory;
@@ -293,7 +293,7 @@ class MsgPackDeserializer {
 
     doubleToFloat(i, o);
     fixEndianness(value);
-    variant->setFloat(value, resources_);
+    VariantImpl::setFloat(value, variant, resources_);
 
     return DeserializationError::Ok;
   }
@@ -349,12 +349,9 @@ class MsgPackDeserializer {
 
     bool allowArray = filter.allowArray();
 
-    ArrayData* array;
     if (allowArray) {
       ARDUINOJSON_ASSERT(variant != 0);
-      array = &variant->toArray();
-    } else {
-      array = 0;
+      variant->toArray();
     }
 
     TFilter elementFilter = filter[0U];
@@ -363,8 +360,7 @@ class MsgPackDeserializer {
       VariantData* value;
 
       if (elementFilter.allow()) {
-        ARDUINOJSON_ASSERT(array != 0);
-        value = array->addElement(resources_);
+        value = VariantImpl::addNewElement(variant, resources_);
         if (!value)
           return DeserializationError::NoMemory;
       } else {
@@ -388,12 +384,9 @@ class MsgPackDeserializer {
     if (nestingLimit.reached())
       return DeserializationError::TooDeep;
 
-    ObjectData* object;
     if (filter.allowObject()) {
       ARDUINOJSON_ASSERT(variant != 0);
-      object = &variant->toObject();
-    } else {
-      object = 0;
+      variant->toObject();
     }
 
     for (; n; --n) {
@@ -406,9 +399,7 @@ class MsgPackDeserializer {
       VariantData* member = 0;
 
       if (memberFilter.allow()) {
-        ARDUINOJSON_ASSERT(object != 0);
-
-        auto keyVariant = object->addPair(&member, resources_);
+        auto keyVariant = VariantImpl::addPair(&member, variant, resources_);
         if (!keyVariant)
           return DeserializationError::NoMemory;
 

src/ArduinoJson/MsgPack/MsgPackExtension.hpp

@@ -30,53 +30,57 @@ class MsgPackExtension {
 
 template <>
 struct Converter<MsgPackExtension> : private detail::VariantAttorney {
-  static void toJson(MsgPackExtension src, JsonVariant dst) {
-    auto data = VariantAttorney::getData(dst);
+  static bool toJson(MsgPackExtension src, JsonVariant dst) {
+    auto data = getData(dst);
     if (!data)
-      return;
-    auto resources = getResourceManager(dst);
-    data->clear(resources);
-    if (src.data()) {
-      uint8_t format, sizeBytes;
-      if (src.size() >= 0x10000) {
-        format = 0xc9;  // ext 32
-        sizeBytes = 4;
-      } else if (src.size() >= 0x100) {
-        format = 0xc8;  // ext 16
-        sizeBytes = 2;
-      } else if (src.size() == 16) {
-        format = 0xd8;  // fixext 16
-        sizeBytes = 0;
-      } else if (src.size() == 8) {
-        format = 0xd7;  // fixext 8
-        sizeBytes = 0;
-      } else if (src.size() == 4) {
-        format = 0xd6;  // fixext 4
-        sizeBytes = 0;
-      } else if (src.size() == 2) {
-        format = 0xd5;  // fixext 2
-        sizeBytes = 0;
-      } else if (src.size() == 1) {
-        format = 0xd4;  // fixext 1
-        sizeBytes = 0;
-      } else {
-        format = 0xc7;  // ext 8
-        sizeBytes = 1;
-      }
+      return false;
 
-      auto str = resources->createString(src.size() + 2 + sizeBytes);
-      if (str) {
-        resources->saveString(str);
-        auto ptr = reinterpret_cast<uint8_t*>(str->data);
-        *ptr++ = uint8_t(format);
-        for (uint8_t i = 0; i < sizeBytes; i++)
-          *ptr++ = uint8_t(src.size() >> (sizeBytes - i - 1) * 8 & 0xff);
-        *ptr++ = uint8_t(src.type());
-        memcpy(ptr, src.data(), src.size());
-        data->setRawString(str);
-        return;
-      }
+    auto resources = getResourceManager(dst);
+    detail::VariantImpl::clear(data, resources);
+
+    if (!src.data())
+      return true;
+
+    uint8_t format, sizeBytes;
+    if (src.size() >= 0x10000) {
+      format = 0xc9;  // ext 32
+      sizeBytes = 4;
+    } else if (src.size() >= 0x100) {
+      format = 0xc8;  // ext 16
+      sizeBytes = 2;
+    } else if (src.size() == 16) {
+      format = 0xd8;  // fixext 16
+      sizeBytes = 0;
+    } else if (src.size() == 8) {
+      format = 0xd7;  // fixext 8
+      sizeBytes = 0;
+    } else if (src.size() == 4) {
+      format = 0xd6;  // fixext 4
+      sizeBytes = 0;
+    } else if (src.size() == 2) {
+      format = 0xd5;  // fixext 2
+      sizeBytes = 0;
+    } else if (src.size() == 1) {
+      format = 0xd4;  // fixext 1
+      sizeBytes = 0;
+    } else {
+      format = 0xc7;  // ext 8
+      sizeBytes = 1;
     }
+
+    auto str = resources->createString(src.size() + 2 + sizeBytes);
+    if (!str)
+      return false;
+
+    resources->saveString(str);
+    auto ptr = reinterpret_cast<uint8_t*>(str->data);
+    *ptr++ = uint8_t(format);
+    for (uint8_t i = 0; i < sizeBytes; i++)
+      *ptr++ = uint8_t(src.size() >> (sizeBytes - i - 1) * 8 & 0xff);
+    *ptr++ = uint8_t(src.type());
+    memcpy(ptr, src.data(), src.size());
+    data->setRawString(str);
+    return true;
   }
 
   static MsgPackExtension fromJson(JsonVariantConst src) {

src/ArduinoJson/MsgPack/MsgPackSerializer.hpp

@@ -19,7 +19,7 @@ class MsgPackSerializer : public VariantDataVisitor<size_t> {
  public:
   static const bool producesText = false;
 
-  MsgPackSerializer(TWriter writer, const ResourceManager* resources)
+  MsgPackSerializer(TWriter writer, ResourceManager* resources)
       : writer_(writer), resources_(resources) {}
 
   template <typename T>
@@ -47,8 +47,11 @@ class MsgPackSerializer : public VariantDataVisitor<size_t> {
     return bytesWritten();
   }
 
-  size_t visit(const ArrayData& array) {
-    size_t n = array.size(resources_);
+  size_t visitArray(VariantData* array) {
+    ARDUINOJSON_ASSERT(array != nullptr);
+    ARDUINOJSON_ASSERT(array->isArray());
+
+    auto n = VariantImpl::size(array, resources_);
     if (n < 0x10) {
       writeByte(uint8_t(0x90 + n));
     } else if (n < 0x10000) {
@@ -59,18 +62,21 @@ class MsgPackSerializer : public VariantDataVisitor<size_t> {
       writeInteger(uint32_t(n));
     }
 
-    auto slotId = array.head();
+    auto slotId = array->content.asCollection.head;
     while (slotId != NULL_SLOT) {
       auto slot = resources_->getVariant(slotId);
-      slot->accept(*this, resources_);
-      slotId = slot->next();
+      VariantImpl::accept(*this, slot, resources_);
+      slotId = slot->next;
     }
 
     return bytesWritten();
   }
 
-  size_t visit(const ObjectData& object) {
-    size_t n = object.size(resources_);
+  size_t visitObject(VariantData* object) {
+    ARDUINOJSON_ASSERT(object != nullptr);
+    ARDUINOJSON_ASSERT(object->isObject());
+
+    auto n = VariantImpl::size(object, resources_);
     if (n < 0x10) {
       writeByte(uint8_t(0x80 + n));
     } else if (n < 0x10000) {
@@ -81,11 +87,11 @@ class MsgPackSerializer : public VariantDataVisitor<size_t> {
       writeInteger(uint32_t(n));
     }
 
-    auto slotId = object.head();
+    auto slotId = object->content.asCollection.head;
     while (slotId != NULL_SLOT) {
       auto slot = resources_->getVariant(slotId);
-      slot->accept(*this, resources_);
-      slotId = slot->next();
+      VariantImpl::accept(*this, slot, resources_);
+      slotId = slot->next;
     }
 
     return bytesWritten();
@@ -209,7 +215,7 @@ class MsgPackSerializer : public VariantDataVisitor<size_t> {
   }
 
   CountingDecorator<TWriter> writer_;
-  const ResourceManager* resources_;
+  ResourceManager* resources_;
 };
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Numbers/FloatParts.hpp

@@ -7,89 +7,86 @@
 #include <ArduinoJson/Configuration.hpp>
 #include <ArduinoJson/Numbers/FloatTraits.hpp>
 #include <ArduinoJson/Numbers/JsonFloat.hpp>
+#include <ArduinoJson/Polyfills/assert.hpp>
 #include <ArduinoJson/Polyfills/math.hpp>
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
 struct FloatParts {
-  uint32_t integral;
-  uint32_t decimal;
+  uint32_t mantissa;
   int16_t exponent;
-  int8_t decimalPlaces;
+  int8_t pointIndex;
 };
 
-template <typename TFloat>
-inline int16_t normalize(TFloat& value) {
-  using traits = FloatTraits<TFloat>;
-  int16_t powersOf10 = 0;
-
-  int8_t index = sizeof(TFloat) == 8 ? 8 : 5;
-  int bit = 1 << index;
-
-  if (value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD) {
-    for (; index >= 0; index--) {
-      if (value >= traits::positiveBinaryPowersOfTen()[index]) {
-        value *= traits::negativeBinaryPowersOfTen()[index];
-        powersOf10 = int16_t(powersOf10 + bit);
-      }
-      bit >>= 1;
-    }
-  }
-
-  if (value > 0 && value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD) {
-    for (; index >= 0; index--) {
-      if (value < traits::negativeBinaryPowersOfTen()[index] * 10) {
-        value *= traits::positiveBinaryPowersOfTen()[index];
-        powersOf10 = int16_t(powersOf10 - bit);
-      }
-      bit >>= 1;
-    }
-  }
-
-  return powersOf10;
-}
-
 constexpr uint32_t pow10(int exponent) {
   return (exponent == 0) ? 1 : 10 * pow10(exponent - 1);
 }
 
-inline FloatParts decomposeFloat(JsonFloat value, int8_t decimalPlaces) {
-  uint32_t maxDecimalPart = pow10(decimalPlaces);
+inline FloatParts decomposeFloat(JsonFloat value, int8_t significantDigits) {
+  ARDUINOJSON_ASSERT(value > 0);
+  ARDUINOJSON_ASSERT(significantDigits > 1);
+  ARDUINOJSON_ASSERT(significantDigits <= 9);  // to prevent uint32_t overflow
 
-  int16_t exponent = normalize(value);
+  using traits = FloatTraits<JsonFloat>;
 
-  uint32_t integral = uint32_t(value);
-  // reduce number of decimal places by the number of integral places
-  for (uint32_t tmp = integral; tmp >= 10; tmp /= 10) {
-    maxDecimalPart /= 10;
-    decimalPlaces--;
-  }
+  bool useScientificNotation =
+      value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD ||
+      value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD;
 
-  JsonFloat remainder =
-      (value - JsonFloat(integral)) * JsonFloat(maxDecimalPart);
+  int16_t exponent = 0;
+  int8_t index = traits::binaryPowersOfTenArraySize - 1;
+  int bit = 1 << index;
 
-  uint32_t decimal = uint32_t(remainder);
-  remainder = remainder - JsonFloat(decimal);
-
-  // rounding:
-  // increment by 1 if remainder >= 0.5
-  decimal += uint32_t(remainder * 2);
-  if (decimal >= maxDecimalPart) {
-    decimal = 0;
-    integral++;
-    if (exponent && integral >= 10) {
-      exponent++;
-      integral = 1;
+  // Normalize value to range [1..10) and compute exponent
+  if (value > 1) {
+    for (; index >= 0; index--) {
+      if (value >= traits::positiveBinaryPowersOfTen()[index]) {
+        value *= traits::negativeBinaryPowersOfTen()[index];
+        exponent = int16_t(exponent + bit);
+      }
+      bit >>= 1;
     }
   }
+  ARDUINOJSON_ASSERT(value < 10);
+  if (value < 1) {
+    for (; index >= 0; index--) {
+      if (value < traits::negativeBinaryPowersOfTen()[index] * 10) {
+        value *= traits::positiveBinaryPowersOfTen()[index];
+        exponent = int16_t(exponent - bit);
+      }
+      bit >>= 1;
+    }
+  }
+  ARDUINOJSON_ASSERT(value >= 1);
+  // ARDUINOJSON_ASSERT(value < 10);
+
+  value *= JsonFloat(pow10(significantDigits - 1));
+
+  auto mantissa = uint32_t(value);
+  ARDUINOJSON_ASSERT(mantissa > 0);
+
+  // rounding
+  auto remainder = value - JsonFloat(mantissa);
+  if (remainder >= 0.5)
+    mantissa++;
+
+  auto pointIndex = int8_t(significantDigits - 1);
+
+  if (!useScientificNotation) {
+    pointIndex = int8_t(pointIndex - int8_t(exponent));
+    exponent = 0;
+  }
 
   // remove trailing zeros
-  while (decimal % 10 == 0 && decimalPlaces > 0) {
-    decimal /= 10;
-    decimalPlaces--;
+  while (mantissa % 10 == 0 && (useScientificNotation || pointIndex > 0)) {
+    mantissa /= 10;
+    if (pointIndex > 0)
+      pointIndex--;
+    else
+      exponent++;
   }
 
-  return {integral, decimal, exponent, decimalPlaces};
+  return {mantissa, exponent, pointIndex};
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Numbers/FloatTraits.hpp

@@ -29,6 +29,8 @@ struct FloatTraits<T, 8 /*64bits*/> {
   using exponent_type = int16_t;
   static const exponent_type exponent_max = 308;
 
+  static const int8_t binaryPowersOfTenArraySize = 9;
+
   static pgm_ptr<T> positiveBinaryPowersOfTen() {
     ARDUINOJSON_DEFINE_PROGMEM_ARRAY(  //
         uint64_t, factors,
@@ -113,6 +115,8 @@ struct FloatTraits<T, 4 /*32bits*/> {
   using exponent_type = int8_t;
   static const exponent_type exponent_max = 38;
 
+  static const int8_t binaryPowersOfTenArraySize = 6;
+
   static pgm_ptr<T> positiveBinaryPowersOfTen() {
     ARDUINOJSON_DEFINE_PROGMEM_ARRAY(uint32_t, factors,
                                      {

src/ArduinoJson/Object/JsonObject.hpp

@@ -20,56 +20,55 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
   using iterator = JsonObjectIterator;
 
   // Creates an unbound reference.
-  JsonObject() : data_(0), resources_(0) {}
+  JsonObject() {}
 
   // INTERNAL USE ONLY
-  JsonObject(detail::ObjectData* data, detail::ResourceManager* resource)
-      : data_(data), resources_(resource) {}
+  JsonObject(const detail::VariantImpl& impl) : impl_(impl) {}
+
+  // INTERNAL USE ONLY
+  JsonObject(detail::VariantData* data, detail::ResourceManager* resource)
+      : impl_(data, resource) {}
 
   operator JsonVariant() const {
-    void* data = data_;  // prevent warning cast-align
-    return JsonVariant(reinterpret_cast<detail::VariantData*>(data),
-                       resources_);
+    return JsonVariant(getData(), getResourceManager());
   }
 
   operator JsonObjectConst() const {
-    return JsonObjectConst(data_, resources_);
+    return JsonObjectConst(getData(), getResourceManager());
   }
 
   operator JsonVariantConst() const {
-    return JsonVariantConst(collectionToVariant(data_), resources_);
+    return JsonVariantConst(getData(), getResourceManager());
   }
 
   // Returns true if the reference is unbound.
   // https://arduinojson.org/v7/api/jsonobject/isnull/
   bool isNull() const {
-    return data_ == 0;
+    return !impl_.isObject();
   }
 
   // Returns true if the reference is bound.
   // https://arduinojson.org/v7/api/jsonobject/isnull/
   operator bool() const {
-    return data_ != 0;
+    return impl_.isObject();
   }
 
   // Returns the depth (nesting level) of the object.
   // https://arduinojson.org/v7/api/jsonobject/nesting/
   size_t nesting() const {
-    return detail::VariantData::nesting(collectionToVariant(data_), resources_);
+    return impl_.nesting();
   }
 
   // Returns the number of members in the object.
   // https://arduinojson.org/v7/api/jsonobject/size/
   size_t size() const {
-    return data_ ? data_->size(resources_) : 0;
+    return impl_.size();
   }
 
   // Returns an iterator to the first key-value pair of the object.
   // https://arduinojson.org/v7/api/jsonobject/begin/
   iterator begin() const {
-    if (!data_)
-      return iterator();
-    return iterator(data_->createIterator(resources_), resources_);
+    return iterator(impl_.createIterator(), impl_.resources());
   }
 
   // Returns an iterator following the last key-value pair of the object.
@@ -81,13 +80,13 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
   // Removes all the members of the object.
   // https://arduinojson.org/v7/api/jsonobject/clear/
   void clear() const {
-    detail::ObjectData::clear(data_, resources_);
+    impl_.empty();
   }
 
   // Copies an object.
   // https://arduinojson.org/v7/api/jsonobject/set/
   bool set(JsonObjectConst src) {
-    if (!data_ || !src.data_)
+    if (isNull() || src.isNull())
       return false;
 
     clear();
@@ -111,9 +110,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
   // Gets or sets the member with specified key.
   // https://arduinojson.org/v7/api/jsonobject/subscript/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   detail::MemberProxy<JsonObject, detail::AdaptedString<TChar*>> operator[](
       TChar* key) const {
     return {*this, detail::adaptString(key)};
@@ -131,7 +128,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
   // Removes the member at the specified iterator.
   // https://arduinojson.org/v7/api/jsonobject/remove/
   FORCE_INLINE void remove(iterator it) const {
-    detail::ObjectData::remove(data_, it.iterator_, resources_);
+    impl_.removeMember(it.iterator_);
   }
 
   // Removes the member with the specified key.
@@ -139,8 +136,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
   template <typename TString,
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   void remove(const TString& key) const {
-    detail::ObjectData::removeMember(data_, detail::adaptString(key),
-                                     resources_);
+    impl_.removeMember(detail::adaptString(key));
   }
 
   // Removes the member with the specified key.
@@ -156,8 +152,7 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
   // https://arduinojson.org/v7/api/jsonobject/remove/
   template <typename TChar>
   FORCE_INLINE void remove(TChar* key) const {
-    detail::ObjectData::removeMember(data_, detail::adaptString(key),
-                                     resources_);
+    impl_.removeMember(detail::adaptString(key));
   }
 
   // DEPRECATED: use obj[key].is<T>() instead
@@ -166,20 +161,16 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   ARDUINOJSON_DEPRECATED("use obj[key].is<T>() instead")
   bool containsKey(const TString& key) const {
-    return detail::ObjectData::getMember(data_, detail::adaptString(key),
-                                         resources_) != 0;
+    return impl_.getMember(detail::adaptString(key)) != 0;
   }
 
   // DEPRECATED: use obj["key"].is<T>() instead
   // https://arduinojson.org/v7/api/jsonobject/containskey/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   ARDUINOJSON_DEPRECATED("use obj[\"key\"].is<T>() instead")
   bool containsKey(TChar* key) const {
-    return detail::ObjectData::getMember(data_, detail::adaptString(key),
-                                         resources_) != 0;
+    return impl_.getMember(detail::adaptString(key)) != 0;
   }
 
   // DEPRECATED: use obj[key].is<T>() instead
@@ -227,19 +218,18 @@ class JsonObject : public detail::VariantOperators<JsonObject> {
 
  private:
   detail::ResourceManager* getResourceManager() const {
-    return resources_;
+    return impl_.resources();
   }
 
   detail::VariantData* getData() const {
-    return detail::collectionToVariant(data_);
+    return impl_.data();
   }
 
   detail::VariantData* getOrCreateData() const {
-    return detail::collectionToVariant(data_);
+    return impl_.data();
   }
 
-  detail::ObjectData* data_;
-  detail::ResourceManager* resources_;
+  mutable detail::VariantImpl impl_;
 };
 
 ARDUINOJSON_END_PUBLIC_NAMESPACE

src/ArduinoJson/Object/JsonObjectConst.hpp

@@ -19,47 +19,47 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
   using iterator = JsonObjectConstIterator;
 
   // Creates an unbound reference.
-  JsonObjectConst() : data_(0), resources_(0) {}
+  JsonObjectConst() {}
 
   // INTERNAL USE ONLY
-  JsonObjectConst(const detail::ObjectData* data,
-                  const detail::ResourceManager* resources)
-      : data_(data), resources_(resources) {}
+  JsonObjectConst(detail::VariantData* data, detail::ResourceManager* resources)
+      : impl_(data, resources) {}
+
+  // INTERNAL USE ONLY
+  JsonObjectConst(const detail::VariantImpl& impl) : impl_(impl) {}
 
   operator JsonVariantConst() const {
-    return JsonVariantConst(getData(), resources_);
+    return JsonVariantConst(impl_.data(), impl_.resources());
   }
 
   // Returns true if the reference is unbound.
   // https://arduinojson.org/v7/api/jsonobjectconst/isnull/
   bool isNull() const {
-    return data_ == 0;
+    return impl_.isNull();
   }
 
   // Returns true if the reference is bound.
   // https://arduinojson.org/v7/api/jsonobjectconst/isnull/
   operator bool() const {
-    return data_ != 0;
+    return !isNull();
   }
 
   // Returns the depth (nesting level) of the object.
   // https://arduinojson.org/v7/api/jsonobjectconst/nesting/
   size_t nesting() const {
-    return detail::VariantData::nesting(getData(), resources_);
+    return impl_.nesting();
   }
 
   // Returns the number of members in the object.
   // https://arduinojson.org/v7/api/jsonobjectconst/size/
   size_t size() const {
-    return data_ ? data_->size(resources_) : 0;
+    return impl_.size();
   }
 
   // Returns an iterator to the first key-value pair of the object.
   // https://arduinojson.org/v7/api/jsonobjectconst/begin/
   iterator begin() const {
-    if (!data_)
-      return iterator();
-    return iterator(data_->createIterator(resources_), resources_);
+    return iterator(impl_.createIterator(), impl_.resources());
   }
 
   // Returns an iterator following the last key-value pair of the object.
@@ -74,8 +74,7 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   ARDUINOJSON_DEPRECATED("use obj[key].is<T>() instead")
   bool containsKey(const TString& key) const {
-    return detail::ObjectData::getMember(data_, detail::adaptString(key),
-                                         resources_) != 0;
+    return impl_.getMember(detail::adaptString(key)) != 0;
   }
 
   // DEPRECATED: use obj["key"].is<T>() instead
@@ -83,8 +82,7 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
   template <typename TChar>
   ARDUINOJSON_DEPRECATED("use obj[\"key\"].is<T>() instead")
   bool containsKey(TChar* key) const {
-    return detail::ObjectData::getMember(data_, detail::adaptString(key),
-                                         resources_) != 0;
+    return impl_.getMember(detail::adaptString(key)) != 0;
   }
 
   // DEPRECATED: use obj[key].is<T>() instead
@@ -101,21 +99,17 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
   template <typename TString,
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   JsonVariantConst operator[](const TString& key) const {
-    return JsonVariantConst(detail::ObjectData::getMember(
-                                data_, detail::adaptString(key), resources_),
-                            resources_);
+    return JsonVariantConst(impl_.getMember(detail::adaptString(key)),
+                            impl_.resources());
   }
 
   // Gets the member with specified key.
   // https://arduinojson.org/v7/api/jsonobjectconst/subscript/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   JsonVariantConst operator[](TChar* key) const {
-    return JsonVariantConst(detail::ObjectData::getMember(
-                                data_, detail::adaptString(key), resources_),
-                            resources_);
+    return JsonVariantConst(impl_.getMember(detail::adaptString(key)),
+                            impl_.resources());
   }
 
   // Gets the member with specified key.
@@ -137,11 +131,10 @@ class JsonObjectConst : public detail::VariantOperators<JsonObjectConst> {
 
  private:
   const detail::VariantData* getData() const {
-    return collectionToVariant(data_);
+    return impl_.data();
   }
 
-  const detail::ObjectData* data_;
-  const detail::ResourceManager* resources_;
+  detail::VariantImpl impl_;
 };
 
 inline bool operator==(JsonObjectConst lhs, JsonObjectConst rhs) {

src/ArduinoJson/Object/JsonObjectIterator.hpp

@@ -14,7 +14,7 @@ class JsonObjectIterator {
  public:
   JsonObjectIterator() {}
 
-  explicit JsonObjectIterator(detail::ObjectData::iterator iterator,
+  explicit JsonObjectIterator(detail::VariantImpl::iterator iterator,
                               detail::ResourceManager* resources)
       : iterator_(iterator), resources_(resources) {}
 
@@ -34,13 +34,13 @@ class JsonObjectIterator {
   }
 
   JsonObjectIterator& operator++() {
-    iterator_.next(resources_);  // key
-    iterator_.next(resources_);  // value
+    iterator_.move(resources_);  // key
+    iterator_.move(resources_);  // value
     return *this;
   }
 
  private:
-  detail::ObjectData::iterator iterator_;
+  detail::VariantImpl::iterator iterator_;
   detail::ResourceManager* resources_;
 };
 
@@ -50,8 +50,8 @@ class JsonObjectConstIterator {
  public:
   JsonObjectConstIterator() {}
 
-  explicit JsonObjectConstIterator(detail::ObjectData::iterator iterator,
-                                   const detail::ResourceManager* resources)
+  explicit JsonObjectConstIterator(detail::VariantImpl::iterator iterator,
+                                   detail::ResourceManager* resources)
       : iterator_(iterator), resources_(resources) {}
 
   JsonPairConst operator*() const {
@@ -70,14 +70,14 @@ class JsonObjectConstIterator {
   }
 
   JsonObjectConstIterator& operator++() {
-    iterator_.next(resources_);  // key
-    iterator_.next(resources_);  // value
+    iterator_.move(resources_);  // key
+    iterator_.move(resources_);  // value
     return *this;
   }
 
  private:
-  detail::ObjectData::iterator iterator_;
-  const detail::ResourceManager* resources_;
+  detail::VariantImpl::iterator iterator_;
+  detail::ResourceManager* resources_;
 };
 
 ARDUINOJSON_END_PUBLIC_NAMESPACE

src/ArduinoJson/Object/JsonPair.hpp

@@ -15,11 +15,11 @@ ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
 class JsonPair {
  public:
   // INTERNAL USE ONLY
-  JsonPair(detail::ObjectData::iterator iterator,
+  JsonPair(detail::VariantImpl::iterator iterator,
            detail::ResourceManager* resources) {
     if (!iterator.done()) {
       key_ = iterator->asString();
-      iterator.next(resources);
+      iterator.move(resources);
       value_ = JsonVariant(iterator.data(), resources);
     }
   }
@@ -43,11 +43,11 @@ class JsonPair {
 // https://arduinojson.org/v7/api/jsonobjectconst/begin_end/
 class JsonPairConst {
  public:
-  JsonPairConst(detail::ObjectData::iterator iterator,
-                const detail::ResourceManager* resources) {
+  JsonPairConst(detail::VariantImpl::iterator iterator,
+                detail::ResourceManager* resources) {
     if (!iterator.done()) {
       key_ = iterator->asString();
-      iterator.next(resources);
+      iterator.move(resources);
       value_ = JsonVariantConst(iterator.data(), resources);
     }
   }

src/ArduinoJson/Object/MemberProxy.hpp

@@ -39,7 +39,7 @@ class MemberProxy
     return *this;
   }
 
-  template <typename T, enable_if_t<!is_const<T>::value, int> = 0>
+  template <typename T>
   MemberProxy& operator=(T* src) {
     this->set(src);
     return *this;
@@ -56,17 +56,15 @@ class MemberProxy
   }
 
   VariantData* getData() const {
-    return VariantData::getMember(
-        VariantAttorney::getData(upstream_), key_,
-        VariantAttorney::getResourceManager(upstream_));
+    return VariantAttorney::getVariantImpl(upstream_).getMember(key_);
   }
 
   VariantData* getOrCreateData() const {
     auto data = VariantAttorney::getOrCreateData(upstream_);
-    if (!data)
-      return nullptr;
-    return data->getOrAddMember(key_,
-                                VariantAttorney::getResourceManager(upstream_));
+    auto resources = VariantAttorney::getResourceManager(upstream_);
+    if (data && data->type == VariantType::Null)
+      data->toObject();
+    return VariantImpl(data, resources).getOrAddMember(key_);
   }
 
  private:

src/ArduinoJson/Object/ObjectData.hpp

@@ -1,70 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2025, Benoit BLANCHON
-// MIT License
-
-#pragma once
-
-#include <ArduinoJson/Collection/CollectionData.hpp>
-
-ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
-
-class ObjectData : public CollectionData {
- public:
-  template <typename TAdaptedString>
-  VariantData* addMember(TAdaptedString key, ResourceManager* resources);
-
-  VariantData* addPair(VariantData** value, ResourceManager* resources);
-
-  template <typename TAdaptedString>
-  VariantData* getOrAddMember(TAdaptedString key, ResourceManager* resources);
-
-  template <typename TAdaptedString>
-  VariantData* getMember(TAdaptedString key,
-                         const ResourceManager* resources) const;
-
-  template <typename TAdaptedString>
-  static VariantData* getMember(const ObjectData* object, TAdaptedString key,
-                                const ResourceManager* resources) {
-    if (!object)
-      return nullptr;
-    return object->getMember(key, resources);
-  }
-
-  template <typename TAdaptedString>
-  void removeMember(TAdaptedString key, ResourceManager* resources);
-
-  template <typename TAdaptedString>
-  static void removeMember(ObjectData* obj, TAdaptedString key,
-                           ResourceManager* resources) {
-    if (!obj)
-      return;
-    obj->removeMember(key, resources);
-  }
-
-  void remove(iterator it, ResourceManager* resources) {
-    CollectionData::removePair(it, resources);
-  }
-
-  static void remove(ObjectData* obj, ObjectData::iterator it,
-                     ResourceManager* resources) {
-    if (!obj)
-      return;
-    obj->remove(it, resources);
-  }
-
-  size_t size(const ResourceManager* resources) const {
-    return CollectionData::size(resources) / 2;
-  }
-
-  static size_t size(const ObjectData* obj, const ResourceManager* resources) {
-    if (!obj)
-      return 0;
-    return obj->size(resources);
-  }
-
- private:
-  template <typename TAdaptedString>
-  iterator findKey(TAdaptedString key, const ResourceManager* resources) const;
-};
-
-ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Object/ObjectImpl.hpp

@@ -4,38 +4,48 @@
 
 #pragma once
 
-#include <ArduinoJson/Object/ObjectData.hpp>
 #include <ArduinoJson/Variant/VariantCompare.hpp>
-#include <ArduinoJson/Variant/VariantData.hpp>
+#include <ArduinoJson/Variant/VariantImpl.hpp>
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
 template <typename TAdaptedString>
-inline VariantData* ObjectData::getMember(
-    TAdaptedString key, const ResourceManager* resources) const {
-  auto it = findKey(key, resources);
+inline VariantData* VariantImpl::getMember(TAdaptedString key,
+                                           VariantData* data,
+                                           ResourceManager* resources) {
+  auto it = findKey(key, data, resources);
   if (it.done())
     return nullptr;
-  it.next(resources);
+  it.move(resources);
   return it.data();
 }
 
 template <typename TAdaptedString>
-VariantData* ObjectData::getOrAddMember(TAdaptedString key,
-                                        ResourceManager* resources) {
-  auto data = getMember(key, resources);
-  if (data)
-    return data;
-  return addMember(key, resources);
+VariantData* VariantImpl::getOrAddMember(TAdaptedString key, VariantData* data,
+                                         ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->isObject());
+  ARDUINOJSON_ASSERT(resources != nullptr);
+
+  auto member = getMember(key, data, resources);
+  if (member)
+    return member;
+  return addMember(key, data, resources);
 }
 
 template <typename TAdaptedString>
-inline ObjectData::iterator ObjectData::findKey(
-    TAdaptedString key, const ResourceManager* resources) const {
+inline VariantImpl::iterator VariantImpl::findKey(TAdaptedString key,
+                                                  VariantData* data,
+                                                  ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->isObject());
+  ARDUINOJSON_ASSERT(resources != nullptr);
+
   if (key.isNull())
     return iterator();
   bool isKey = true;
-  for (auto it = createIterator(resources); !it.done(); it.next(resources)) {
+  for (auto it = createIterator(data, resources); !it.done();
+       it.move(resources)) {
     if (isKey && stringEquals(key, adaptString(it->asString())))
       return it;
     isKey = !isKey;
@@ -44,14 +54,16 @@ inline ObjectData::iterator ObjectData::findKey(
 }
 
 template <typename TAdaptedString>
-inline void ObjectData::removeMember(TAdaptedString key,
-                                     ResourceManager* resources) {
-  remove(findKey(key, resources), resources);
-}
+inline VariantData* VariantImpl::addMember(TAdaptedString key,
+                                           VariantData* data,
+                                           ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->isObject());
+  ARDUINOJSON_ASSERT(resources != nullptr);
+
+  if (key.isNull())
+    return nullptr;  // Ignore null key
 
-template <typename TAdaptedString>
-inline VariantData* ObjectData::addMember(TAdaptedString key,
-                                          ResourceManager* resources) {
   auto keySlot = resources->allocVariant();
   if (!keySlot)
     return nullptr;
@@ -60,16 +72,21 @@ inline VariantData* ObjectData::addMember(TAdaptedString key,
   if (!valueSlot)
     return nullptr;
 
-  if (!keySlot->setString(key, resources))
+  if (!VariantImpl::setString(key, keySlot.ptr(), resources))
     return nullptr;
 
-  CollectionData::appendPair(keySlot, valueSlot, resources);
+  appendPair(keySlot, valueSlot, data, resources);
 
   return valueSlot.ptr();
 }
 
-inline VariantData* ObjectData::addPair(VariantData** value,
-                                        ResourceManager* resources) {
+inline VariantData* VariantImpl::addPair(VariantData** value, VariantData* data,
+                                         ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(value != nullptr);
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->isObject());
+  ARDUINOJSON_ASSERT(resources != nullptr);
+
   auto keySlot = resources->allocVariant();
   if (!keySlot)
     return nullptr;
@@ -79,14 +96,14 @@ inline VariantData* ObjectData::addPair(VariantData** value,
     return nullptr;
   *value = valueSlot.ptr();
 
-  CollectionData::appendPair(keySlot, valueSlot, resources);
+  appendPair(keySlot, valueSlot, data, resources);
 
   return keySlot.ptr();
 }
 
 // Returns the size (in bytes) of an object with n members.
 constexpr size_t sizeofObject(size_t n) {
-  return 2 * n * ResourceManager::slotSize;
+  return 2 * n * sizeof(VariantData);
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Serialization/measure.hpp

@@ -14,7 +14,7 @@ size_t measure(ArduinoJson::JsonVariantConst source) {
   auto data = VariantAttorney::getData(source);
   auto resources = VariantAttorney::getResourceManager(source);
   TSerializer<DummyWriter> serializer(dp, resources);
-  return VariantData::accept(data, resources, serializer);
+  return VariantImpl::accept(serializer, data, resources);
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Serialization/serialize.hpp

@@ -13,7 +13,7 @@ size_t doSerialize(ArduinoJson::JsonVariantConst source, TWriter writer) {
   auto data = VariantAttorney::getData(source);
   auto resources = VariantAttorney::getResourceManager(source);
   TSerializer<TWriter> serializer(writer, resources);
-  return VariantData::accept(data, resources, serializer);
+  return VariantImpl::accept(serializer, data, resources);
 }
 
 template <template <typename> class TSerializer, typename TDestination>

src/ArduinoJson/Strings/Adapters/FlashString.hpp

@@ -63,10 +63,6 @@ class FlashString {
     ::memcpy_P(p, s.str_, n);
   }
 
-  bool isStatic() const {
-    return false;
-  }
-
  private:
   const char* str_;
   size_t size_;

src/ArduinoJson/Strings/Adapters/RamString.hpp

@@ -20,14 +20,8 @@ struct IsChar
 class RamString {
  public:
   static const size_t typeSortKey = 2;
-#if ARDUINOJSON_SIZEOF_POINTER <= 2
-  static constexpr size_t sizeMask = size_t(-1) >> 1;
-#else
-  static constexpr size_t sizeMask = size_t(-1);
-#endif
 
-  RamString(const char* str, size_t sz, bool isStatic = false)
-      : str_(str), size_(sz & sizeMask), static_(isStatic) {
+  RamString(const char* str, size_t sz) : str_(str), size_(sz) {
     ARDUINOJSON_ASSERT(size_ == sz);
   }
 
@@ -49,21 +43,9 @@ class RamString {
     return str_;
   }
 
-  bool isStatic() const {
-    return static_;
-  }
-
  protected:
   const char* str_;
-
-#if ARDUINOJSON_SIZEOF_POINTER <= 2
-  // Use a bitfield only on 8-bit microcontrollers
-  size_t size_ : sizeof(size_t) * 8 - 1;
-  bool static_ : 1;
-#else
   size_t size_;
-  bool static_;
-#endif
 };
 
 template <typename TChar>
@@ -76,36 +58,6 @@ struct StringAdapter<TChar*, enable_if_t<IsChar<TChar>::value>> {
   }
 };
 
-template <typename TChar>
-struct StringAdapter<TChar[], enable_if_t<IsChar<TChar>::value>> {
-  using AdaptedString = RamString;
-
-  static AdaptedString adapt(const TChar* p) {
-    auto str = reinterpret_cast<const char*>(p);
-    return AdaptedString(str, str ? ::strlen(str) : 0);
-  }
-};
-
-template <size_t N>
-struct StringAdapter<const char (&)[N]> {
-  using AdaptedString = RamString;
-
-  static AdaptedString adapt(const char (&p)[N]) {
-    return RamString(p, N - 1, true);
-  }
-};
-
-template <typename TChar, size_t N>
-struct StringAdapter<TChar[N], enable_if_t<IsChar<TChar>::value>> {
-  using AdaptedString = RamString;
-
-  static AdaptedString adapt(const TChar* p) {
-    ARDUINOJSON_ASSERT(p);
-    auto str = reinterpret_cast<const char*>(p);
-    return AdaptedString(str, ::strlen(str));
-  }
-};
-
 template <typename TChar>
 struct SizedStringAdapter<TChar*, enable_if_t<IsChar<TChar>::value>> {
   using AdaptedString = RamString;

src/ArduinoJson/Strings/JsonString.hpp

@@ -19,17 +19,25 @@ class JsonString {
   friend struct detail::StringAdapter<JsonString>;
 
  public:
-  JsonString() : str_(nullptr, 0, true) {}
+  JsonString() : str_(nullptr, 0) {}
 
-  JsonString(const char* data, bool isStatic = false)
-      : str_(data, data ? ::strlen(data) : 0, isStatic) {}
+  JsonString(const char* data) : str_(data, data ? ::strlen(data) : 0) {}
+
+  ARDUINOJSON_DEPRECATED(
+      "ArduinoJson doesn't differentiate between static and dynamic strings "
+      "anymore. Remove the second argument to fix this warning.")
+  JsonString(const char* data, bool) : JsonString(data) {}
 
   template <typename TSize,
             detail::enable_if_t<detail::is_integral<TSize>::value &&
                                     !detail::is_same<TSize, bool>::value,
                                 int> = 0>
-  JsonString(const char* data, TSize sz, bool isStatic = false)
-      : str_(data, size_t(sz), isStatic) {}
+  JsonString(const char* data, TSize sz) : str_(data, size_t(sz)) {}
+
+  ARDUINOJSON_DEPRECATED(
+      "ArduinoJson doesn't differentiate between static and dynamic strings "
+      "anymore. Remove the third argument to fix this warning.")
+  JsonString(const char* data, size_t sz, bool) : JsonString(data, sz) {}
 
   // Returns a pointer to the characters.
   const char* c_str() const {
@@ -41,10 +49,10 @@ class JsonString {
     return str_.isNull();
   }
 
-  // Returns true if the string is stored by address.
-  // Returns false if the string is stored by copy.
+  // Deprecated: always returns false.
+  ARDUINOJSON_DEPRECATED("The isStatic() was removed in v7.5")
   bool isStatic() const {
-    return str_.isStatic();
+    return false;
   }
 
   // Returns length of the string.

src/ArduinoJson/Strings/StringAdapter.hpp

@@ -8,13 +8,6 @@
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
-// a meta function that tells if the type is a string literal (const char[N])
-template <typename T>
-struct IsStringLiteral : false_type {};
-
-template <size_t N>
-struct IsStringLiteral<const char (&)[N]> : true_type {};
-
 template <typename TString, typename Enable = void>
 struct StringAdapter;
 
@@ -22,9 +15,7 @@ template <typename TString, typename Enable = void>
 struct SizedStringAdapter;
 
 template <typename TString>
-using StringAdapterFor =
-    StringAdapter<conditional_t<IsStringLiteral<TString>::value, TString,
-                                remove_cv_t<remove_reference_t<TString>>>>;
+using StringAdapterFor = StringAdapter<decay_t<TString>>;
 
 template <typename T>
 using AdaptedString = typename StringAdapterFor<T>::AdaptedString;
@@ -34,7 +25,7 @@ AdaptedString<TString> adaptString(TString&& s) {
   return StringAdapterFor<TString>::adapt(detail::forward<TString>(s));
 }
 
-template <typename TChar, enable_if_t<!is_const<TChar>::value, int> = 0>
+template <typename TChar>
 AdaptedString<TChar*> adaptString(TChar* p) {
   return StringAdapter<TChar*>::adapt(p);
 }

src/ArduinoJson/Variant/ConverterImpl.hpp

@@ -25,9 +25,10 @@ struct Converter {
                 "type 'char' is not supported, use 'signed char', 'unsigned "
                 "char' or another integer type instead");
 
-  static void toJson(const T& src, JsonVariant dst) {
+  static auto toJson(const T& src, JsonVariant dst)
+      -> decltype(convertToJson(src, dst)) {
     // clang-format off
-    convertToJson(src, dst); // Error here? See https://arduinojson.org/v7/unsupported-set/
+    return convertToJson(src, dst); // Error here? See https://arduinojson.org/v7/unsupported-set/
     // clang-format on
   }
 
@@ -60,25 +61,16 @@ struct Converter<T, detail::enable_if_t<detail::is_integral<T>::value &&
     : private detail::VariantAttorney {
   static bool toJson(T src, JsonVariant dst) {
     ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
-    auto data = getData(dst);
-    if (!data)
-      return false;
-    auto resources = getResourceManager(dst);
-    data->clear(resources);
-    return data->setInteger(src, resources);
+    return getVariantImpl(dst).setInteger(src);
   }
 
   static T fromJson(JsonVariantConst src) {
     ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T);
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return data ? data->template asIntegral<T>(resources) : T();
+    return getVariantImpl(src).template asIntegral<T>();
   }
 
   static bool checkJson(JsonVariantConst src) {
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return data && data->template isInteger<T>(resources);
+    return getVariantImpl(src).template isInteger<T>();
   }
 };
 
@@ -90,35 +82,22 @@ struct Converter<T, detail::enable_if_t<detail::is_enum<T>::value>>
   }
 
   static T fromJson(JsonVariantConst src) {
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return data ? static_cast<T>(data->template asIntegral<int>(resources))
-                : T();
+    return static_cast<T>(getVariantImpl(src).template asIntegral<int>());
   }
 
   static bool checkJson(JsonVariantConst src) {
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return data && data->template isInteger<int>(resources);
+    return getVariantImpl(src).template isInteger<int>();
   }
 };
 
 template <>
 struct Converter<bool> : private detail::VariantAttorney {
   static bool toJson(bool src, JsonVariant dst) {
-    auto data = getData(dst);
-    if (!data)
-      return false;
-    auto resources = getResourceManager(dst);
-    data->clear(resources);
-    data->setBoolean(src);
-    return true;
+    return getVariantImpl(dst).setBoolean(src);
   }
 
   static bool fromJson(JsonVariantConst src) {
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return data ? data->asBoolean(resources) : false;
+    return getVariantImpl(src).asBoolean();
   }
 
   static bool checkJson(JsonVariantConst src) {
@@ -131,18 +110,11 @@ template <typename T>
 struct Converter<T, detail::enable_if_t<detail::is_floating_point<T>::value>>
     : private detail::VariantAttorney {
   static bool toJson(T src, JsonVariant dst) {
-    auto data = getData(dst);
-    if (!data)
-      return false;
-    auto resources = getResourceManager(dst);
-    data->clear(resources);
-    return data->setFloat(src, resources);
+    return getVariantImpl(dst).setFloat(src);
   }
 
   static T fromJson(JsonVariantConst src) {
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return data ? data->template asFloat<T>(resources) : 0;
+    return getVariantImpl(src).template asFloat<T>();
   }
 
   static bool checkJson(JsonVariantConst src) {
@@ -153,9 +125,8 @@ struct Converter<T, detail::enable_if_t<detail::is_floating_point<T>::value>>
 
 template <>
 struct Converter<const char*> : private detail::VariantAttorney {
-  static void toJson(const char* src, JsonVariant dst) {
-    detail::VariantData::setString(getData(dst), detail::adaptString(src),
-                                   getResourceManager(dst));
+  static bool toJson(const char* src, JsonVariant dst) {
+    return getVariantImpl(dst).setString(detail::adaptString(src));
   }
 
   static const char* fromJson(JsonVariantConst src) {
@@ -171,9 +142,8 @@ struct Converter<const char*> : private detail::VariantAttorney {
 
 template <>
 struct Converter<JsonString> : private detail::VariantAttorney {
-  static void toJson(JsonString src, JsonVariant dst) {
-    detail::VariantData::setString(getData(dst), detail::adaptString(src),
-                                   getResourceManager(dst));
+  static bool toJson(JsonString src, JsonVariant dst) {
+    return getVariantImpl(dst).setString(detail::adaptString(src));
   }
 
   static JsonString fromJson(JsonVariantConst src) {
@@ -188,12 +158,10 @@ struct Converter<JsonString> : private detail::VariantAttorney {
 };
 
 template <typename T>
-inline detail::enable_if_t<detail::IsString<T>::value> convertToJson(
+inline detail::enable_if_t<detail::IsString<T>::value, bool> convertToJson(
     const T& src, JsonVariant dst) {
-  using namespace detail;
-  auto data = VariantAttorney::getData(dst);
-  auto resources = VariantAttorney::getResourceManager(dst);
-  detail::VariantData::setString(data, adaptString(src), resources);
+  return detail::VariantAttorney::getVariantImpl(dst).setString(
+      detail::adaptString(src));
 }
 
 // SerializedValue<std::string>
@@ -201,16 +169,16 @@ inline detail::enable_if_t<detail::IsString<T>::value> convertToJson(
 // SerializedValue<const __FlashStringHelper*>
 template <typename T>
 struct Converter<SerializedValue<T>> : private detail::VariantAttorney {
-  static void toJson(SerializedValue<T> src, JsonVariant dst) {
-    detail::VariantData::setRawString(getData(dst), src,
-                                      getResourceManager(dst));
+  static bool toJson(SerializedValue<T> src, JsonVariant dst) {
+    return getVariantImpl(dst).setRawString(
+        detail::adaptString(src.data(), src.size()));
   }
 };
 
 template <>
 struct Converter<detail::nullptr_t> : private detail::VariantAttorney {
-  static void toJson(detail::nullptr_t, JsonVariant dst) {
-    detail::VariantData::clear(getData(dst), getResourceManager(dst));
+  static bool toJson(detail::nullptr_t, JsonVariant dst) {
+    return getVariantImpl(dst).clear();
   }
   static detail::nullptr_t fromJson(JsonVariantConst) {
     return nullptr;
@@ -258,17 +226,18 @@ class StringBuilderPrint : public Print {
 };
 }  // namespace detail
 
-inline void convertToJson(const ::Printable& src, JsonVariant dst) {
+inline bool convertToJson(const ::Printable& src, JsonVariant dst) {
   auto resources = detail::VariantAttorney::getResourceManager(dst);
   auto data = detail::VariantAttorney::getData(dst);
   if (!resources || !data)
-    return;
-  data->clear(resources);
+    return false;
+  detail::VariantImpl::clear(data, resources);
   detail::StringBuilderPrint print(resources);
   src.printTo(print);
   if (print.overflowed())
-    return;
+    return false;
   print.save(data);
+  return true;
 }
 
 #endif
@@ -321,17 +290,15 @@ inline bool canConvertFromJson(JsonVariantConst src, const std::string_view&) {
 
 template <>
 struct Converter<JsonArrayConst> : private detail::VariantAttorney {
-  static void toJson(JsonArrayConst src, JsonVariant dst) {
+  static bool toJson(JsonArrayConst src, JsonVariant dst) {
     if (src.isNull())
-      dst.set(nullptr);
+      return dst.set(nullptr);
     else
-      dst.to<JsonArray>().set(src);
+      return dst.to<JsonArray>().set(src);
   }
 
   static JsonArrayConst fromJson(JsonVariantConst src) {
-    auto data = getData(src);
-    auto array = data ? data->asArray() : nullptr;
-    return JsonArrayConst(array, getResourceManager(src));
+    return JsonArrayConst(getData(src), getResourceManager(src));
   }
 
   static bool checkJson(JsonVariantConst src) {
@@ -342,17 +309,15 @@ struct Converter<JsonArrayConst> : private detail::VariantAttorney {
 
 template <>
 struct Converter<JsonArray> : private detail::VariantAttorney {
-  static void toJson(JsonVariantConst src, JsonVariant dst) {
+  static bool toJson(JsonVariantConst src, JsonVariant dst) {
     if (src.isNull())
-      dst.set(nullptr);
+      return dst.set(nullptr);
     else
-      dst.to<JsonArray>().set(src);
+      return dst.to<JsonArray>().set(src);
   }
 
   static JsonArray fromJson(JsonVariant src) {
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return JsonArray(data != 0 ? data->asArray() : 0, resources);
+    return JsonArray(getData(src), getResourceManager(src));
   }
 
   static bool checkJson(JsonVariant src) {
@@ -363,17 +328,15 @@ struct Converter<JsonArray> : private detail::VariantAttorney {
 
 template <>
 struct Converter<JsonObjectConst> : private detail::VariantAttorney {
-  static void toJson(JsonVariantConst src, JsonVariant dst) {
+  static bool toJson(JsonVariantConst src, JsonVariant dst) {
     if (src.isNull())
-      dst.set(nullptr);
+      return dst.set(nullptr);
     else
-      dst.to<JsonObject>().set(src);
+      return dst.to<JsonObject>().set(src);
   }
 
   static JsonObjectConst fromJson(JsonVariantConst src) {
-    auto data = getData(src);
-    auto object = data != 0 ? data->asObject() : nullptr;
-    return JsonObjectConst(object, getResourceManager(src));
+    return JsonObjectConst(getData(src), getResourceManager(src));
   }
 
   static bool checkJson(JsonVariantConst src) {
@@ -384,17 +347,15 @@ struct Converter<JsonObjectConst> : private detail::VariantAttorney {
 
 template <>
 struct Converter<JsonObject> : private detail::VariantAttorney {
-  static void toJson(JsonVariantConst src, JsonVariant dst) {
+  static bool toJson(JsonVariantConst src, JsonVariant dst) {
     if (src.isNull())
-      dst.set(nullptr);
+      return dst.set(nullptr);
     else
-      dst.to<JsonObject>().set(src);
+      return dst.to<JsonObject>().set(src);
   }
 
   static JsonObject fromJson(JsonVariant src) {
-    auto data = getData(src);
-    auto resources = getResourceManager(src);
-    return JsonObject(data != 0 ? data->asObject() : 0, resources);
+    return JsonObject(getData(src), getResourceManager(src));
   }
 
   static bool checkJson(JsonVariant src) {

src/ArduinoJson/Variant/JsonVariant.hpp

@@ -16,27 +16,29 @@ class JsonVariant : public detail::VariantRefBase<JsonVariant>,
 
  public:
   // Creates an unbound reference.
-  JsonVariant() : data_(0), resources_(0) {}
+  JsonVariant() {}
 
   // INTERNAL USE ONLY
   JsonVariant(detail::VariantData* data, detail::ResourceManager* resources)
-      : data_(data), resources_(resources) {}
+      : impl_(data, resources) {}
+
+  // INTERNAL USE ONLY
+  JsonVariant(detail::VariantImpl impl) : impl_(impl) {}
 
  private:
   detail::ResourceManager* getResourceManager() const {
-    return resources_;
+    return impl_.resources();
   }
 
   detail::VariantData* getData() const {
-    return data_;
+    return impl_.data();
   }
 
   detail::VariantData* getOrCreateData() const {
-    return data_;
+    return impl_.data();
   }
 
-  detail::VariantData* data_;
-  detail::ResourceManager* resources_;
+  mutable detail::VariantImpl impl_;
 };
 
 namespace detail {
@@ -45,8 +47,8 @@ bool copyVariant(JsonVariant dst, JsonVariantConst src);
 
 template <>
 struct Converter<JsonVariant> : private detail::VariantAttorney {
-  static void toJson(JsonVariantConst src, JsonVariant dst) {
-    copyVariant(dst, src);
+  static bool toJson(JsonVariantConst src, JsonVariant dst) {
+    return copyVariant(dst, src);
   }
 
   static JsonVariant fromJson(JsonVariant src) {
@@ -61,8 +63,8 @@ struct Converter<JsonVariant> : private detail::VariantAttorney {
 
 template <>
 struct Converter<JsonVariantConst> : private detail::VariantAttorney {
-  static void toJson(JsonVariantConst src, JsonVariant dst) {
-    copyVariant(dst, src);
+  static bool toJson(JsonVariantConst src, JsonVariant dst) {
+    return copyVariant(dst, src);
   }
 
   static JsonVariantConst fromJson(JsonVariantConst src) {

src/ArduinoJson/Variant/JsonVariantConst.hpp

@@ -35,34 +35,34 @@ class JsonVariantConst : public detail::VariantTag,
 
  public:
   // Creates an unbound reference.
-  JsonVariantConst() : data_(nullptr), resources_(nullptr) {}
+  JsonVariantConst() {}
 
   // INTERNAL USE ONLY
-  explicit JsonVariantConst(const detail::VariantData* data,
-                            const detail::ResourceManager* resources)
-      : data_(data), resources_(resources) {}
+  explicit JsonVariantConst(detail::VariantData* data,
+                            detail::ResourceManager* resources)
+      : impl_(data, resources) {}
 
   // Returns true if the value is null or the reference is unbound.
   // https://arduinojson.org/v7/api/jsonvariantconst/isnull/
   bool isNull() const {
-    return detail::VariantData::isNull(data_);
+    return impl_.isNull();
   }
 
   // Returns true if the reference is unbound.
   bool isUnbound() const {
-    return !data_;
+    return impl_.data() == nullptr;
   }
 
   // Returns the depth (nesting level) of the value.
   // https://arduinojson.org/v7/api/jsonvariantconst/nesting/
   size_t nesting() const {
-    return detail::VariantData::nesting(data_, resources_);
+    return impl_.nesting();
   }
 
   // Returns the size of the array or object.
   // https://arduinojson.org/v7/api/jsonvariantconst/size/
   size_t size() const {
-    return detail::VariantData::size(data_, resources_);
+    return impl_.size();
   }
 
   // Casts the value to the specified type.
@@ -104,9 +104,7 @@ class JsonVariantConst : public detail::VariantTag,
   template <typename T,
             detail::enable_if_t<detail::is_integral<T>::value, int> = 0>
   JsonVariantConst operator[](T index) const {
-    return JsonVariantConst(
-        detail::VariantData::getElement(data_, size_t(index), resources_),
-        resources_);
+    return JsonVariantConst(impl_.getElement(size_t(index)), impl_.resources());
   }
 
   // Gets object's member with specified key.
@@ -114,21 +112,17 @@ class JsonVariantConst : public detail::VariantTag,
   template <typename TString,
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   JsonVariantConst operator[](const TString& key) const {
-    return JsonVariantConst(detail::VariantData::getMember(
-                                data_, detail::adaptString(key), resources_),
-                            resources_);
+    return JsonVariantConst(impl_.getMember(detail::adaptString(key)),
+                            impl_.resources());
   }
 
   // Gets object's member with specified key.
   // https://arduinojson.org/v7/api/jsonvariantconst/subscript/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   JsonVariantConst operator[](TChar* key) const {
-    return JsonVariantConst(detail::VariantData::getMember(
-                                data_, detail::adaptString(key), resources_),
-                            resources_);
+    return JsonVariantConst(impl_.getMember(detail::adaptString(key)),
+                            impl_.resources());
   }
 
   // Gets object's member with specified key or the array's element at the
@@ -149,20 +143,16 @@ class JsonVariantConst : public detail::VariantTag,
             detail::enable_if_t<detail::IsString<TString>::value, int> = 0>
   ARDUINOJSON_DEPRECATED("use var[key].is<T>() instead")
   bool containsKey(const TString& key) const {
-    return detail::VariantData::getMember(getData(), detail::adaptString(key),
-                                          resources_) != 0;
+    return impl_.getMember(detail::adaptString(key)) != 0;
   }
 
   // DEPRECATED: use obj["key"].is<T>() instead
   // https://arduinojson.org/v7/api/jsonvariantconst/containskey/
   template <typename TChar,
-            detail::enable_if_t<detail::IsString<TChar*>::value &&
-                                    !detail::is_const<TChar>::value,
-                                int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value, int> = 0>
   ARDUINOJSON_DEPRECATED("use obj[\"key\"].is<T>() instead")
   bool containsKey(TChar* key) const {
-    return detail::VariantData::getMember(getData(), detail::adaptString(key),
-                                          resources_) != 0;
+    return impl_.getMember(detail::adaptString(key)) != 0;
   }
 
   // DEPRECATED: use obj[key].is<T>() instead
@@ -181,17 +171,16 @@ class JsonVariantConst : public detail::VariantTag,
   }
 
  protected:
-  const detail::VariantData* getData() const {
-    return data_;
+  detail::VariantData* getData() const {
+    return impl_.data();
   }
 
-  const detail::ResourceManager* getResourceManager() const {
-    return resources_;
+  detail::ResourceManager* getResourceManager() const {
+    return impl_.resources();
   }
 
  private:
-  const detail::VariantData* data_;
-  const detail::ResourceManager* resources_;
+  mutable detail::VariantImpl impl_;
 };
 
 ARDUINOJSON_END_PUBLIC_NAMESPACE

src/ArduinoJson/Variant/JsonVariantVisitor.hpp

@@ -26,15 +26,15 @@ class VisitorAdapter {
  public:
   using result_type = typename TVisitor::result_type;
 
-  VisitorAdapter(TVisitor& visitor, const ResourceManager* resources)
+  VisitorAdapter(TVisitor& visitor, ResourceManager* resources)
       : visitor_(&visitor), resources_(resources) {}
 
-  result_type visit(const ArrayData& value) {
-    return visitor_->visit(JsonArrayConst(&value, resources_));
+  result_type visitArray(VariantData* data) {
+    return visitor_->visit(JsonArrayConst(data, resources_));
   }
 
-  result_type visit(const ObjectData& value) {
-    return visitor_->visit(JsonObjectConst(&value, resources_));
+  result_type visitObject(VariantData* data) {
+    return visitor_->visit(JsonObjectConst(data, resources_));
   }
 
   template <typename T>
@@ -44,18 +44,15 @@ class VisitorAdapter {
 
  private:
   TVisitor* visitor_;
-  const ResourceManager* resources_;
+  ResourceManager* resources_;
 };
 
 template <typename TVisitor>
 typename TVisitor::result_type accept(JsonVariantConst variant,
                                       TVisitor& visit) {
-  auto data = VariantAttorney::getData(variant);
-  if (!data)
-    return visit.visit(nullptr);
-  auto resources = VariantAttorney::getResourceManager(variant);
-  VisitorAdapter<TVisitor> adapter(visit, resources);
-  return data->accept(adapter, resources);
+  VisitorAdapter<TVisitor> adapter(
+      visit, VariantAttorney::getResourceManager(variant));
+  return VariantAttorney::getVariantImpl(variant).accept(adapter);
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Variant/VariantAttorney.hpp

@@ -6,8 +6,7 @@
 
 #include <ArduinoJson/Polyfills/attributes.hpp>
 #include <ArduinoJson/Polyfills/type_traits.hpp>
-#include <ArduinoJson/Variant/VariantData.hpp>
-#include <ArduinoJson/Variant/VariantTo.hpp>
+#include <ArduinoJson/Variant/VariantImpl.hpp>
 #include "JsonVariantConst.hpp"
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
@@ -26,6 +25,16 @@ class VariantAttorney {
     return client.getData();
   }
 
+  template <typename TClient>
+  static VariantImpl getVariantImpl(TClient& client) {
+    return VariantImpl(client.getData(), client.getResourceManager());
+  }
+
+  template <typename TClient>
+  static VariantImpl getOrCreateVariantImpl(TClient& client) {
+    return VariantImpl(client.getOrCreateData(), client.getResourceManager());
+  }
+
   template <typename TClient>
   static VariantData* getOrCreateData(TClient& client) {
     return client.getOrCreateData();

src/ArduinoJson/Variant/VariantContent.hpp

@@ -6,32 +6,29 @@
 
 #include <stddef.h>  // size_t
 
-#include <ArduinoJson/Array/ArrayData.hpp>
 #include <ArduinoJson/Numbers/JsonFloat.hpp>
 #include <ArduinoJson/Numbers/JsonInteger.hpp>
-#include <ArduinoJson/Object/ObjectData.hpp>
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
 enum class VariantTypeBits : uint8_t {
   OwnedStringBit = 0x01,  // 0000 0001
   NumberBit = 0x08,       // 0000 1000
-#if ARDUINOJSON_USE_EXTENSIONS
-  ExtensionBit = 0x10,  // 0001 0000
+#if ARDUINOJSON_USE_8_BYTE_POOL
+  EightByteBit = 0x10,  // 0001 0000
 #endif
   CollectionMask = 0x60,
 };
 
 enum class VariantType : uint8_t {
-  Null = 0,             // 0000 0000
-  TinyString = 0x02,    // 0000 0010
-  RawString = 0x03,     // 0000 0011
-  LinkedString = 0x04,  // 0000 0100
-  OwnedString = 0x05,   // 0000 0101
-  Boolean = 0x06,       // 0000 0110
-  Uint32 = 0x0A,        // 0000 1010
-  Int32 = 0x0C,         // 0000 1100
-  Float = 0x0E,         // 0000 1110
+  Null = 0,           // 0000 0000
+  TinyString = 0x02,  // 0000 0010
+  RawString = 0x03,   // 0000 0011
+  LongString = 0x05,  // 0000 0101
+  Boolean = 0x06,     // 0000 0110
+  Uint32 = 0x0A,      // 0000 1010
+  Int32 = 0x0C,       // 0000 1100
+  Float = 0x0E,       // 0000 1110
 #if ARDUINOJSON_USE_LONG_LONG
   Uint64 = 0x1A,  // 0001 1010
   Int64 = 0x1C,   // 0001 1100
@@ -47,6 +44,18 @@ inline bool operator&(VariantType type, VariantTypeBits bit) {
   return (uint8_t(type) & uint8_t(bit)) != 0;
 }
 
+struct CollectionData {
+  SlotId head = NULL_SLOT;
+  SlotId tail = NULL_SLOT;
+
+  // Placement new
+  static void* operator new(size_t, void* p) noexcept {
+    return p;
+  }
+
+  static void operator delete(void*, void*) noexcept {}
+};
+
 const size_t tinyStringMaxLength = 3;
 
 union VariantContent {
@@ -56,19 +65,16 @@ union VariantContent {
   bool asBoolean;
   uint32_t asUint32;
   int32_t asInt32;
-#if ARDUINOJSON_USE_EXTENSIONS
+#if ARDUINOJSON_USE_8_BYTE_POOL
   SlotId asSlotId;
 #endif
-  ArrayData asArray;
-  ObjectData asObject;
   CollectionData asCollection;
-  const char* asLinkedString;
-  struct StringNode* asOwnedString;
+  struct StringNode* asStringNode;
   char asTinyString[tinyStringMaxLength + 1];
 };
 
-#if ARDUINOJSON_USE_EXTENSIONS
-union VariantExtension {
+#if ARDUINOJSON_USE_8_BYTE_POOL
+union EightByteValue {
 #  if ARDUINOJSON_USE_LONG_LONG
   uint64_t asUint64;
   int64_t asInt64;
@@ -77,6 +83,9 @@ union VariantExtension {
   double asDouble;
 #  endif
 };
+
+static_assert(sizeof(EightByteValue) == 8,
+              "sizeof(EightByteValue) must be 8 bytes");
 #endif
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE