JsonObject: replace ObjectData* member with VariantData*

This new pool replaced the "extension" slot where a secondary variant slot was used to store 8-byte values.

.github/workflows/ci.yml

@@ -179,19 +179,19 @@ jobs:
 
   conf_test_windows:
     name: Test configuration on Windows
-    runs-on: windows-2022
+    runs-on: windows-2019
     needs: [gcc, clang]
     steps:
       - name: Checkout
         uses: actions/checkout@v4
       - name: 32-bit
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars32.bat"
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars32.bat"
           cl /Isrc extras/conf_test/x86.cpp
         shell: cmd
       - name: 64-bit
         run: |
-          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           cl /Isrc extras/conf_test/x64.cpp
         shell: cmd
 
@@ -398,9 +398,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Install Particle CLI
-        run: |
-          bash <( curl -sL https://particle.io/install-cli )
-          echo "$HOME/bin" >> $GITHUB_PATH
+        run: sudo npm install -g particle-cli
       - name: Login to Particle
         run: particle login -t "${{ secrets.PARTICLE_TOKEN }}"
       - name: Compile

CHANGELOG.md

@@ -4,41 +4,39 @@ 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.
+* Optimize storage of static strings
 
 > ### BREAKING CHANGES
 >
-> #### `JsonString` constructor's boolean parameter
+> Static string cannot contain NUL characters anymore (they could since 7.3.0).
+> This is an extremely rare case, so you probably won't be affected.
 >
-> 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.
+> For example, the following code produces different output in 7.3 and 7.4:
 >
-> ```diff
->   char name[] = "ArduinoJson";
-> - doc["name"] = JsonString(name, true);
-> + doc["name"] = name;
+> ```cpp
+> JsonDocument doc;
+> doc["a\0b"] = "c\0d";
+> serializeJson(doc, Serial);
+> // With Arduino 7.3 -> {"a\u0000b":"c\u0000d"}
+> // With Arduino 7.4 -> {"a":"c"}
 > ```
 >
-> #### 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.
+> `JsonString` contructor now only accepts two arguments, not three.
+> If your code uses `JsonString` to store a string as a pointer, you must remove the size argument.
 >
-> If you do need to include NULs in your string, you must use a `JsonString` instead:
+> For example, if you have something like this:
 >
-> ```diff
-> - doc["strings"] = "hello\0world"
-> + doc["strings"] = JsonString("hello\0world", 11)
+> ```cpp
+> doc["key"] = JsonString(str.c_str(), str.size(), true);
+> ```
+>
+> You must replace with either:
+>
+> ```cpp
+> doc["key"] = JsonString(str.c_str(), true);  // store as pointer, cannot contain NUL characters
+> doc["key"] = JsonString(str.c_str(), str.size()); // store by copy, NUL characters allowed
+> doc["key"] = str; // same as previous line for supported string classes (`String`, `std::string`, etc.)
 > ```
-
-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.2)
+project(ArduinoJson VERSION 7.4.1)
 
 if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
 	include(CTest)

README.md

@@ -139,6 +139,11 @@ 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.2.{build}
+version: 7.4.1.{build}
 environment:
   matrix:
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022

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 == "AAAAAA");
+    REQUIRE(allocatorLog == "AAAA");
   }
 
   SECTION("capacity") {

extras/tests/Helpers/Allocators.hpp

@@ -275,6 +275,12 @@ inline size_t sizeofPool(
   return ArduinoJson::detail::MemoryPool<T>::slotsToBytes(n);
 }
 
+inline size_t sizeofStaticStringPool(
+    ArduinoJson::detail::SlotCount n = ARDUINOJSON_POOL_CAPACITY) {
+  using namespace ArduinoJson::detail;
+  return MemoryPool<const char*>::slotsToBytes(n);
+}
+
 inline size_t sizeofStringBuffer(size_t iteration = 1) {
   // returns 31, 63, 127, 255, etc.
   auto capacity = ArduinoJson::detail::StringBuilder::initialCapacity;

extras/tests/JsonArray/add.cpp

@@ -57,7 +57,7 @@ TEST_CASE("JsonArray::add(T)") {
     REQUIRE(array[0].is<int>() == false);
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofString("hello")),
+                             Allocate(sizeofStaticStringPool()),
                          });
   }
 

extras/tests/JsonDeserializer/destination_types.cpp

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

extras/tests/JsonDeserializer/filter.cpp

@@ -825,7 +825,9 @@ TEST_CASE("shrink filter") {
 
   deserializeJson(doc, "{}", DeserializationOption::Filter(filter));
 
-  REQUIRE(spy.log() == AllocatorLog{
-                           Reallocate(sizeofPool(), sizeofObject(1)),
-                       });
+  REQUIRE(spy.log() ==
+          AllocatorLog{
+              Reallocate(sizeofPool(), sizeofObject(1)),
+              Reallocate(sizeofStaticStringPool(), sizeofStaticStringPool(1)),
+          });
 }

extras/tests/JsonDocument/ElementProxy.cpp

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

extras/tests/JsonDocument/MemberProxy.cpp

@@ -25,7 +25,7 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[42]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofString("hello")),
+                             Allocate(sizeofStaticStringPool()),
                          });
   }
 
@@ -35,8 +35,7 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[\"world\"]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofString("hello")),
-                             Allocate(sizeofString("world")),
+                             Allocate(sizeofStaticStringPool()),
                          });
   }
 
@@ -47,7 +46,7 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[\"world\"]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofString("hello")),
+                             Allocate(sizeofStaticStringPool()),
                              Allocate(sizeofString("world")),
                          });
   }
@@ -59,9 +58,8 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[\"world\"]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofString("hello")),
+                             Allocate(sizeofStaticStringPool()),
                              Allocate(sizeofString("world")),
-
                          });
   }
 
@@ -76,7 +74,7 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[\"world\"]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofString("hello")),
+                             Allocate(sizeofStaticStringPool()),
                              Allocate(sizeofString("world")),
                          });
   }
@@ -405,7 +403,7 @@ TEST_CASE("MemberProxy under memory constraints") {
   }
 
   SECTION("value slot allocation fails") {
-    timebomb.setCountdown(1);
+    timebomb.setCountdown(2);
 
     // fill the pool entirely, but leave one slot for the key
     doc["foo"][ARDUINOJSON_POOL_CAPACITY - 4] = 1;
@@ -418,6 +416,7 @@ TEST_CASE("MemberProxy under memory constraints") {
     REQUIRE(doc.overflowed() == true);
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
+                             Allocate(sizeofStaticStringPool()),
                              AllocateFail(sizeofPool()),
                          });
   }

extras/tests/JsonDocument/add.cpp

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

extras/tests/JsonDocument/constructor.cpp

@@ -8,6 +8,8 @@
 #include "Allocators.hpp"
 #include "Literals.hpp"
 
+using ArduinoJson::detail::addPadding;
+
 TEST_CASE("JsonDocument constructor") {
   SpyingAllocator spyingAllocator;
 
@@ -62,8 +64,7 @@ TEST_CASE("JsonDocument constructor") {
     REQUIRE(doc2.as<std::string>() == "{\"hello\":\"world\"}");
     REQUIRE(spyingAllocator.log() == AllocatorLog{
                                          Allocate(sizeofPool()),
-                                         Allocate(sizeofString("hello")),
-                                         Allocate(sizeofString("world")),
+                                         Allocate(sizeofStaticStringPool()),
                                      });
   }
 
@@ -87,7 +88,7 @@ TEST_CASE("JsonDocument constructor") {
     REQUIRE(doc2.as<std::string>() == "[\"hello\"]");
     REQUIRE(spyingAllocator.log() == AllocatorLog{
                                          Allocate(sizeofPool()),
-                                         Allocate(sizeofString("hello")),
+                                         Allocate(sizeofStaticStringPool()),
                                      });
   }
 

extras/tests/JsonDocument/remove.cpp

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

extras/tests/JsonDocument/set.cpp

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

extras/tests/JsonDocument/shrinkToFit.cpp

@@ -69,8 +69,21 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
     REQUIRE(spyingAllocator.log() == AllocatorLog{});
   }
 
-  SECTION("string") {
-    doc.set("abcdefg");
+  SECTION("linked string") {
+    doc.set("hello");
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "hello");
+    REQUIRE(spyingAllocator.log() ==
+            AllocatorLog{
+                Allocate(sizeofStaticStringPool()),
+                Reallocate(sizeofStaticStringPool(), sizeofStaticStringPool(1)),
+            });
+  }
+
+  SECTION("owned string") {
+    doc.set("abcdefg"_s);
     REQUIRE(doc.as<std::string>() == "abcdefg");
 
     doc.shrinkToFit();
@@ -92,7 +105,22 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
                                      });
   }
 
-  SECTION("object key") {
+  SECTION("linked key") {
+    doc["key"] = 42;
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "{\"key\":42}");
+    REQUIRE(spyingAllocator.log() ==
+            AllocatorLog{
+                Allocate(sizeofPool()),
+                Allocate(sizeofStaticStringPool()),
+                Reallocate(sizeofPool(), sizeofObject(1)),
+                Reallocate(sizeofStaticStringPool(), sizeofStaticStringPool(1)),
+            });
+  }
+
+  SECTION("owned key") {
     doc["abcdefg"_s] = 42;
 
     doc.shrinkToFit();
@@ -106,7 +134,22 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
             });
   }
 
-  SECTION("string in array") {
+  SECTION("linked string in array") {
+    doc.add("hello");
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "[\"hello\"]");
+    REQUIRE(spyingAllocator.log() ==
+            AllocatorLog{
+                Allocate(sizeofPool()),
+                Allocate(sizeofStaticStringPool()),
+                Reallocate(sizeofPool(), sizeofArray(1)),
+                Reallocate(sizeofStaticStringPool(), sizeofStaticStringPool(1)),
+            });
+  }
+
+  SECTION("owned string in array") {
     doc.add("abcdefg"_s);
 
     doc.shrinkToFit();
@@ -120,16 +163,32 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
             });
   }
 
-  SECTION("string in object") {
-    doc["key"] = "abcdefg"_s;
+  SECTION("linked string in object") {
+    doc["key"] = "hello";
 
     doc.shrinkToFit();
 
-    REQUIRE(doc.as<std::string>() == "{\"key\":\"abcdefg\"}");
+    REQUIRE(doc.as<std::string>() == "{\"key\":\"hello\"}");
     REQUIRE(spyingAllocator.log() ==
             AllocatorLog{
                 Allocate(sizeofPool()),
-                Allocate(sizeofString("abcdefg")),
+                Allocate(sizeofStaticStringPool()),
+                Reallocate(sizeofPool(), sizeofObject(1)),
+                Reallocate(sizeofStaticStringPool(), sizeofStaticStringPool(2)),
+            });
+  }
+
+  SECTION("owned string in object") {
+    doc["key1"_s] = "value"_s;
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "{\"key1\":\"value\"}");
+    REQUIRE(spyingAllocator.log() ==
+            AllocatorLog{
+                Allocate(sizeofPool()),
+                Allocate(sizeofString("key1")),
+                Allocate(sizeofString("value")),
                 Reallocate(sizeofPool(), sizeofPool(2)),
             });
   }

extras/tests/JsonDocument/subscript.cpp

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

extras/tests/JsonObject/set.cpp

@@ -16,12 +16,26 @@ TEST_CASE("JsonObject::set()") {
   JsonObject obj1 = doc1.to<JsonObject>();
   JsonObject obj2 = doc2.to<JsonObject>();
 
-  SECTION("copy key and string value") {
+  SECTION("doesn't copy static string in key or 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()),
+                             Allocate(sizeofStaticStringPool()),
+                         });
+  }
+
+  SECTION("copy local string key and value") {
+    obj1["hello"_s] = "world"_s;
+    spy.clearLog();
+
+    bool success = obj2.set(obj1);
+
     REQUIRE(success == true);
     REQUIRE(obj2["hello"] == "world"_s);
     REQUIRE(spy.log() == AllocatorLog{

extras/tests/JsonObject/subscript.cpp

@@ -101,8 +101,34 @@ TEST_CASE("JsonObject::operator[]") {
     obj[key] = 42;
     REQUIRE(42 == obj[key]);
   }
-  SECTION("should duplicate key and value strings") {
+
+  SECTION("string literals") {
     obj["hello"] = "world";
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofStaticStringPool()),
+                         });
+  }
+
+  SECTION("should duplicate char* value") {
+    obj["hello"] = const_cast<char*>("world");
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofStaticStringPool()),
+                             Allocate(sizeofString("world")),
+                         });
+  }
+
+  SECTION("should duplicate char* key") {
+    obj[const_cast<char*>("hello")] = 42;
+    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")),
@@ -110,6 +136,48 @@ TEST_CASE("JsonObject::operator[]") {
                          });
   }
 
+  SECTION("should duplicate std::string value") {
+    obj["hello"] = "world"_s;
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofStaticStringPool()),
+                             Allocate(sizeofString("world")),
+                         });
+  }
+
+  SECTION("should duplicate std::string key") {
+    obj["hello"_s] = 42;
+    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)] = 42;
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("hello")),
+                         });
+  }
+
+  SECTION("should not duplicate a static JsonString key") {
+    obj[JsonString("hello", true)] = 42;
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofStaticStringPool()),
+                         });
+  }
+
   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,90 +9,124 @@
 #include "Literals.hpp"
 
 template <typename T>
-std::string serialize(T value) {
+void check(T value, const std::string& expected) {
   JsonDocument doc;
   doc.to<JsonVariant>().set(value);
-  std::string output;
-  serializeJson(doc, output);
-  return output;
+  char buffer[256] = "";
+  size_t returnValue = serializeJson(doc, buffer, sizeof(buffer));
+  REQUIRE(expected == buffer);
+  REQUIRE(expected.size() == returnValue);
 }
 
 TEST_CASE("serializeJson(JsonVariant)") {
-  SECTION("JsonVariant") {
-    CHECK(serialize(JsonVariant()) == "null");
+  SECTION("Undefined") {
+    check(JsonVariant(), "null");
+  }
+
+  SECTION("Null string") {
+    check(static_cast<char*>(0), "null");
   }
 
   SECTION("const char*") {
-    CHECK(serialize(static_cast<const char*>(0)) == "null");
-    CHECK(serialize("hello") == "\"hello\"");
+    check("hello", "\"hello\"");
   }
 
-  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("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("SerializedValue<const char*>") {
-    CHECK(serialize(serialized("[1,2]")) == "[1,2]");
+    check(serialized("[1,2]"), "[1,2]");
   }
 
   SECTION("SerializedValue<std::string>") {
-    CHECK(serialize(serialized("[1,2]"_s)) == "[1,2]");
+    check(serialized("[1,2]"_s), "[1,2]");
   }
 
-  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("Double") {
+    check(3.1415927, "3.1415927");
   }
 
-  SECTION("float") {
+  SECTION("Float") {
     REQUIRE(sizeof(float) == 4);
-    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");
+    check(3.1415927f, "3.141593");
   }
 
-  SECTION("int") {
-    CHECK(serialize(0) == "0");
-    CHECK(serialize(42) == "42");
-    CHECK(serialize(-42) == "-42");
+  SECTION("Zero") {
+    check(0, "0");
   }
 
-  SECTION("unsigned long") {
-    CHECK(serialize(4294967295UL) == "4294967295");
+  SECTION("Integer") {
+    check(42, "42");
   }
 
-  SECTION("bool") {
-    CHECK(serialize(true) == "true");
-    CHECK(serialize(false) == "false");
+  SECTION("NegativeLong") {
+    check(-42, "-42");
+  }
+
+  SECTION("UnsignedLong") {
+    check(4294967295UL, "4294967295");
+  }
+
+  SECTION("True") {
+    check(true, "true");
+  }
+
+  SECTION("OneFalse") {
+    check(false, "false");
   }
 
 #if ARDUINOJSON_USE_LONG_LONG
-  SECTION("int64_t") {
-    CHECK(serialize(-9223372036854775807 - 1) == "-9223372036854775808");
-    CHECK(serialize(9223372036854775807) == "9223372036854775807");
+  SECTION("NegativeInt64") {
+    check(-9223372036854775807 - 1, "-9223372036854775808");
   }
 
-  SECTION("uint64_t") {
-    CHECK(serialize(18446744073709551615U) == "18446744073709551615");
+  SECTION("PositiveInt64") {
+    check(9223372036854775807, "9223372036854775807");
+  }
+
+  SECTION("UInt64") {
+    check(18446744073709551615U, "18446744073709551615");
   }
 #endif
 }

extras/tests/JsonVariant/as.cpp

@@ -185,6 +185,7 @@ 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\")") {
@@ -207,6 +208,7 @@ 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\"))") {
@@ -218,6 +220,7 @@ 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,14 +38,14 @@ TEST_CASE("JsonVariant::set(JsonVariant)") {
     REQUIRE(var1.as<std::string>() == "{\"value\":[42]}");
   }
 
-  SECTION("stores string literals by copy") {
+  SECTION("stores string literals by pointer") {
     var1.set("hello!!");
     spyingAllocator.clearLog();
 
     var2.set(var1);
 
     REQUIRE(spyingAllocator.log() == AllocatorLog{
-                                         Allocate(sizeofString("hello!!")),
+                                         Allocate(sizeofStaticStringPool()),
                                      });
   }
 

extras/tests/JsonVariant/set.cpp

@@ -18,13 +18,14 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
   JsonVariant variant = doc.to<JsonVariant>();
 
   SECTION("string literal") {
-    bool result = variant.set("hello world");
+    bool result = variant.set("hello\0world");
 
     REQUIRE(result == true);
-    REQUIRE(variant == "hello world"_s);  // stores by copy
-    REQUIRE(spy.log() == AllocatorLog{
-                             Allocate(sizeofString(11)),
-                         });
+    CHECK(variant ==
+          "hello"_s);  // linked string cannot contain '\0' at the moment
+    CHECK(spy.log() == AllocatorLog{
+                           Allocate(sizeofStaticStringPool()),
+                       });
   }
 
   SECTION("const char*") {
@@ -141,7 +142,21 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
                          });
   }
 
-  SECTION("JsonString") {
+  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{
+                             Allocate(sizeofStaticStringPool()),
+                         });
+  }
+
+  SECTION("non-static JsonString") {
     char str[16];
 
     strcpy(str, "hello");
@@ -254,6 +269,20 @@ TEST_CASE("JsonVariant::set() with not enough memory") {
 
   JsonVariant v = doc.to<JsonVariant>();
 
+  SECTION("string literal") {
+    bool result = v.set("hello world");
+
+    REQUIRE(result == false);
+    REQUIRE(v.isNull());
+  }
+
+  SECTION("static JsonString") {
+    bool result = v.set(JsonString("hello world", true));
+
+    REQUIRE(result == false);
+    REQUIRE(v.isNull());
+  }
+
   SECTION("std::string") {
     bool result = v.set("hello world!!"_s);
 

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["abcd"_s] = "ABCD";
+    object["abc\0d"_s] = "ABCD";
 
     SECTION("string literal") {
       REQUIRE(var["ab"] == "AB"_s);
       REQUIRE(var["abc"] == "ABC"_s);
-      REQUIRE(var["abcd"] == "ABCD"_s);
+      REQUIRE(var["abc\0d"] == "ABC"_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["abcd"_s] == "ABCD"_s);
+      REQUIRE(var["abc\0d"_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"] = "abcd"_s;
+      object["key3"] = "abc\0d"_s;
       object["key4"] = "foo";
 
       REQUIRE(var[var["key1"]] == "AB"_s);

extras/tests/Misc/CMakeLists.txt

@@ -29,23 +29,3 @@ 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,6 +13,7 @@ TEST_CASE("JsonString") {
 
     CHECK(s.isNull() == true);
     CHECK(s.c_str() == 0);
+    CHECK(s.isStatic() == true);
     CHECK(s == JsonString());
     CHECK(s != "");
   }
@@ -95,6 +96,7 @@ 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

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

@@ -1,15 +0,0 @@
-// 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,8 +2,6 @@
 #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,8 +1,6 @@
 #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,71 +89,58 @@ 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("serializeMsgPack()") {
-    SECTION("bin 32 serialization") {
-      auto str = std::string(65536, '?');
-      doc.set(MsgPackBinary(str.data(), str.size()));
+  SECTION("bin 32 deserialization") {
+    auto str = std::string(65536, '?');
+    auto input = "\xc6\x00\x01\x00\x00"_s + str;
 
-      std::string output;
-      auto result = serializeMsgPack(doc, output);
+    auto err = deserializeMsgPack(doc, input);
 
-      REQUIRE(result == 5 + str.size());
-      REQUIRE(output == "\xc6\x00\x01\x00\x00"_s + str);
-    }
+    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 serialization") {
-      auto str = std::string(65536, '?');
-      doc.set(MsgPackExtension(42, str.data(), str.size()));
+  SECTION("bin 32 serialization") {
+    auto str = std::string(65536, '?');
+    doc.set(MsgPackBinary(str.data(), str.size()));
 
-      std::string output;
-      auto result = serializeMsgPack(doc, output);
+    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 == "\xc6\x00\x01\x00\x00"_s + str);
+  }
 
-    SECTION("str 32 serialization") {
-      auto str = std::string(65536, '?');
-      doc.set(str);
+  SECTION("ext 32 deserialization") {
+    auto str = std::string(65536, '?');
+    auto input = "\xc9\x00\x01\x00\x00\x2a"_s + str;
 
-      std::string output;
-      auto result = serializeMsgPack(doc, output);
+    auto err = deserializeMsgPack(doc, input);
 
-      REQUIRE(result == 5 + str.size());
-      REQUIRE(output == "\xDB\x00\x01\x00\x00"_s + str);
-    }
+    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);
   }
 }

extras/tests/MsgPackDeserializer/destination_types.cpp

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

extras/tests/MsgPackSerializer/serializeVariant.cpp

@@ -137,12 +137,11 @@ 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(shortest.c_str(), "\xDB\x00\x01\x00\x00"_s + shortest);
+    checkVariant(JsonString(shortest.c_str(), true),  // force store by pointer
+                 "\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,6 +4,7 @@
 
 add_executable(NumbersTests
 	convertNumber.cpp
+	decomposeFloat.cpp
 	parseDouble.cpp
 	parseFloat.cpp
 	parseInteger.cpp

extras/tests/Numbers/decomposeFloat.cpp

@@ -0,0 +1,42 @@
+// 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/CMakeLists.txt

@@ -5,6 +5,7 @@
 add_executable(ResourceManagerTests
 	allocVariant.cpp
 	clear.cpp
+	saveStaticString.cpp
 	saveString.cpp
 	shrinkToFit.cpp
 	size.cpp

extras/tests/ResourceManager/StringBuffer.cpp

@@ -2,8 +2,7 @@
 // Copyright © 2014-2025, Benoit BLANCHON
 // MIT License
 
-#include <ArduinoJson/Memory/StringBuffer.hpp>
-#include <ArduinoJson/Variant/VariantImpl.hpp>
+#include <ArduinoJson.hpp>
 #include <catch.hpp>
 
 #include "Allocators.hpp"
@@ -22,8 +21,8 @@ TEST_CASE("StringBuffer") {
     strcpy(ptr, "hi!");
     sb.save(&variant);
 
-    REQUIRE(variant.type == VariantType::TinyString);
-    REQUIRE(variant.asString() == "hi!");
+    REQUIRE(variant.type() == VariantType::TinyString);
+    REQUIRE(variant.asString(&resources) == "hi!");
   }
 
   SECTION("Tiny string can't contain NUL") {
@@ -31,9 +30,9 @@ TEST_CASE("StringBuffer") {
     memcpy(ptr, "a\0b", 3);
     sb.save(&variant);
 
-    REQUIRE(variant.type == VariantType::LongString);
+    REQUIRE(variant.type() == VariantType::OwnedString);
 
-    auto str = variant.asString();
+    auto str = variant.asString(&resources);
     REQUIRE(str.size() == 3);
     REQUIRE(str.c_str()[0] == 'a');
     REQUIRE(str.c_str()[1] == 0);
@@ -45,7 +44,7 @@ TEST_CASE("StringBuffer") {
     strcpy(ptr, "alfa");
     sb.save(&variant);
 
-    REQUIRE(variant.type == VariantType::LongString);
-    REQUIRE(variant.asString() == "alfa");
+    REQUIRE(variant.type() == VariantType::OwnedString);
+    REQUIRE(variant.asString(&resources) == "alfa");
   }
 }

extras/tests/ResourceManager/StringBuilder.cpp

@@ -2,8 +2,7 @@
 // Copyright © 2014-2025, Benoit BLANCHON
 // MIT License
 
-#include <ArduinoJson/Memory/StringBuilder.hpp>
-#include <ArduinoJson/Variant/VariantImpl.hpp>
+#include <ArduinoJson.hpp>
 #include <catch.hpp>
 
 #include "Allocators.hpp"
@@ -27,7 +26,7 @@ TEST_CASE("StringBuilder") {
     REQUIRE(spyingAllocator.log() == AllocatorLog{
                                          Allocate(sizeofStringBuffer()),
                                      });
-    REQUIRE(data.type == VariantType::TinyString);
+    REQUIRE(data.type() == VariantType::TinyString);
   }
 
   SECTION("Tiny string") {
@@ -46,8 +45,8 @@ TEST_CASE("StringBuilder") {
     str.save(&data);
 
     REQUIRE(resources.overflowed() == false);
-    REQUIRE(data.type == VariantType::TinyString);
-    REQUIRE(data.asString() == "url");
+    REQUIRE(data.type() == VariantType::TinyString);
+    REQUIRE(data.asString(&resources) == "url");
   }
 
   SECTION("Short string fits in first allocation") {
@@ -135,9 +134,10 @@ TEST_CASE("StringBuilder::save() deduplicates strings") {
     auto s2 = saveString(builder, "world");
     auto s3 = saveString(builder, "hello");
 
-    REQUIRE(s1.asString() == "hello");
-    REQUIRE(s2.asString() == "world");
-    REQUIRE(+s1.asString().c_str() == +s3.asString().c_str());  // same address
+    REQUIRE(s1.asString(&resources) == "hello");
+    REQUIRE(s2.asString(&resources) == "world");
+    REQUIRE(+s1.asString(&resources).c_str() ==
+            +s3.asString(&resources).c_str());  // same address
 
     REQUIRE(spy.log() ==
             AllocatorLog{
@@ -153,10 +153,10 @@ TEST_CASE("StringBuilder::save() deduplicates strings") {
     auto s1 = saveString(builder, "hello world");
     auto s2 = saveString(builder, "hello");
 
-    REQUIRE(s1.asString() == "hello world");
-    REQUIRE(s2.asString() == "hello");
-    REQUIRE(+s2.asString().c_str() !=
-            +s1.asString().c_str());  // different address
+    REQUIRE(s1.asString(&resources) == "hello world");
+    REQUIRE(s2.asString(&resources) == "hello");
+    REQUIRE(+s2.asString(&resources).c_str() !=
+            +s1.asString(&resources).c_str());  // different address
 
     REQUIRE(spy.log() ==
             AllocatorLog{
@@ -171,10 +171,10 @@ TEST_CASE("StringBuilder::save() deduplicates strings") {
     auto s1 = saveString(builder, "hello world");
     auto s2 = saveString(builder, "worl");
 
-    REQUIRE(s1.asString() == "hello world");
-    REQUIRE(s2.asString() == "worl");
-    REQUIRE(s2.asString().c_str() !=
-            s1.asString().c_str());  // different address
+    REQUIRE(s1.asString(&resources) == "hello world");
+    REQUIRE(s2.asString(&resources) == "worl");
+    REQUIRE(s2.asString(&resources).c_str() !=
+            s1.asString(&resources).c_str());  // different address
 
     REQUIRE(spy.log() ==
             AllocatorLog{

extras/tests/ResourceManager/allocVariant.cpp

@@ -5,8 +5,6 @@
 #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/saveStaticString.cpp

@@ -0,0 +1,47 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson/Memory/ResourceManager.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+#include <catch.hpp>
+
+#include "Allocators.hpp"
+
+using namespace ArduinoJson::detail;
+
+TEST_CASE("ResourceManager::saveStaticString() deduplicates strings") {
+  SpyingAllocator spy;
+  ResourceManager resources(&spy);
+
+  auto str1 = "hello";
+  auto str2 = "world";
+
+  auto id1 = resources.saveStaticString(str1);
+  auto id2 = resources.saveStaticString(str2);
+  REQUIRE(id1 != id2);
+
+  auto id3 = resources.saveStaticString(str1);
+  REQUIRE(id1 == id3);
+
+  resources.shrinkToFit();
+  REQUIRE(spy.log() ==
+          AllocatorLog{
+              Allocate(sizeofStaticStringPool()),
+              Reallocate(sizeofStaticStringPool(), sizeofStaticStringPool(2)),
+          });
+  REQUIRE(resources.overflowed() == false);
+}
+
+TEST_CASE("ResourceManager::saveStaticString() when allocation fails") {
+  SpyingAllocator spy(FailingAllocator::instance());
+  ResourceManager resources(&spy);
+
+  auto slotId = resources.saveStaticString("hello");
+
+  REQUIRE(slotId == NULL_SLOT);
+  REQUIRE(resources.overflowed() == true);
+  REQUIRE(spy.log() == AllocatorLog{
+                           AllocateFail(sizeofStaticStringPool()),
+                       });
+}

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

idf_component.yml

@@ -1,7 +1,7 @@
-version: "7.4.2"
+version: "7.4.1"
 description: >-
   A simple and efficient JSON library for embedded C++.
-  ★ 6953 stars on GitHub!
+  ★ 6898 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++. ⭐ 6953 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++. ⭐ 6898 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.2",
+  "version": "7.4.1",
   "authors": {
     "name": "Benoit Blanchon",
     "url": "https://blog.benoitblanchon.fr"

library.properties

@@ -1,9 +1,9 @@
 name=ArduinoJson
-version=7.4.2
+version=7.4.1
 author=Benoit Blanchon <blog.benoitblanchon.fr>
 maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
 sentence=A simple and efficient JSON library for embedded C++.
-paragraph=⭐ 6953 stars on GitHub! Supports serialization, deserialization, MessagePack, streams, filtering, and more. Fully tested and documented.
+paragraph=⭐ 6898 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,15 +26,6 @@
 #  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"
@@ -45,11 +36,13 @@
 #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

@@ -0,0 +1,66 @@
+// 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,47 +4,42 @@
 
 #pragma once
 
+#include <ArduinoJson/Array/ArrayData.hpp>
 #include <ArduinoJson/Variant/VariantCompare.hpp>
-#include <ArduinoJson/Variant/VariantImpl.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
-inline VariantImpl::iterator VariantImpl::at(size_t index) const {
-  if (!isArray())
-    return iterator();
-
-  auto it = createIterator();
+inline ArrayData::iterator ArrayData::at(
+    size_t index, const ResourceManager* resources) const {
+  auto it = createIterator(resources);
   while (!it.done() && index) {
-    it.move(resources_);
+    it.next(resources);
     --index;
   }
   return it;
 }
 
-inline VariantData* VariantImpl::addNewElement(VariantData* data,
-                                               ResourceManager* resources) {
-  ARDUINOJSON_ASSERT(data != nullptr);
-  ARDUINOJSON_ASSERT(data->isArray());
-  ARDUINOJSON_ASSERT(resources != nullptr);
-
+inline VariantData* ArrayData::addElement(ResourceManager* resources) {
   auto slot = resources->allocVariant();
   if (!slot)
     return nullptr;
-  addElement(slot, data, resources);
+  CollectionData::appendOne(slot, resources);
   return slot.ptr();
 }
 
-inline VariantData* VariantImpl::getOrAddElement(size_t index) {
-  auto it = createIterator();
+inline VariantData* ArrayData::getOrAddElement(size_t index,
+                                               ResourceManager* resources) {
+  auto it = createIterator(resources);
   while (!it.done() && index > 0) {
-    it.move(resources_);
+    it.next(resources);
     index--;
   }
   if (it.done())
     index++;
   VariantData* element = it.data();
   while (index > 0) {
-    element = addNewElement();
+    element = addElement(resources);
     if (!element)
       return nullptr;
     index--;
@@ -52,12 +47,28 @@ inline VariantData* VariantImpl::getOrAddElement(size_t index) {
   return element;
 }
 
-inline VariantData* VariantImpl::getElement(size_t index) const {
-  return at(index).data();
+inline VariantData* ArrayData::getElement(
+    size_t index, const ResourceManager* resources) const {
+  return at(index, resources).data();
 }
 
-inline void VariantImpl::removeElement(size_t index) {
-  removeElement(at(index));
+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;
 }
 
 // Returns the size (in bytes) of an array with n elements.

src/ArduinoJson/Array/ElementProxy.hpp

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

src/ArduinoJson/Array/JsonArray.hpp

@@ -20,25 +20,24 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
   using iterator = JsonArrayIterator;
 
   // Constructs an unbound reference.
-  JsonArray() {}
+  JsonArray() : data_(0), resources_(0) {}
 
   // INTERNAL USE ONLY
   JsonArray(detail::VariantData* data, detail::ResourceManager* resources)
-      : impl_(data, resources) {}
-
-  // INTERNAL USE ONLY
-  JsonArray(const detail::VariantImpl& impl) : impl_(impl) {}
+      : data_(data), resources_(resources) {}
 
   // Returns a JsonVariant pointing to the array.
   // https://arduinojson.org/v7/api/jsonvariant/
   operator JsonVariant() {
-    return JsonVariant(getData(), getResourceManager());
+    void* data = data_;  // prevent warning cast-align
+    return JsonVariant(reinterpret_cast<detail::VariantData*>(data),
+                       resources_);
   }
 
   // Returns a read-only reference to the array.
   // https://arduinojson.org/v7/api/jsonarrayconst/
   operator JsonArrayConst() const {
-    return JsonArrayConst(getData(), getResourceManager());
+    return JsonArrayConst(getData(), resources_);
   }
 
   // Appends a new (empty) element to the array.
@@ -56,16 +55,15 @@ 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(impl_.addNewElement(), impl_.resources());
+    return JsonVariant(detail::VariantData::addElement(data_, resources_),
+                       resources_);
   }
 
   // Appends a value to the array.
   // https://arduinojson.org/v7/api/jsonarray/add/
   template <typename T>
   bool add(const T& value) const {
-    if (!impl_.isArray())
-      return false;
-    return addValue(value, impl_.data(), impl_.resources());
+    return detail::VariantData::addValue(data_, value, resources_);
   }
 
   // Appends a value to the array.
@@ -73,15 +71,16 @@ 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 {
-    if (!impl_.isArray())
-      return false;
-    return addValue(value, impl_.data(), impl_.resources());
+    return detail::VariantData::addValue(data_, value, resources_);
   }
 
   // Returns an iterator to the first element of the array.
   // https://arduinojson.org/v7/api/jsonarray/begin/
   iterator begin() const {
-    return iterator(impl_.createIterator(), impl_.resources());
+    auto array = detail::VariantData::asArray(data_);
+    if (!array)
+      return iterator();
+    return iterator(array->createIterator(resources_), resources_);
   }
 
   // Returns an iterator following the last element of the array.
@@ -93,6 +92,9 @@ 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))
@@ -105,13 +107,14 @@ 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 {
-    impl_.removeElement(it.iterator_);
+    detail::ArrayData::remove(detail::VariantData::asArray(data_), it.iterator_,
+                              resources_);
   }
 
   // Removes the element at the specified index.
   // https://arduinojson.org/v7/api/jsonarray/remove/
   void remove(size_t index) const {
-    impl_.removeElement(index);
+    detail::VariantData::removeElement(data_, index, resources_);
   }
 
   // Removes the element at the specified index.
@@ -126,7 +129,7 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
   // Removes all the elements of the array.
   // https://arduinojson.org/v7/api/jsonarray/clear/
   void clear() const {
-    impl_.empty();
+    detail::ArrayData::clear(detail::VariantData::asArray(data_), resources_);
   }
 
   // Gets or sets the element at the specified index.
@@ -149,13 +152,13 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
   }
 
   operator JsonVariantConst() const {
-    return JsonVariantConst(getData(), getResourceManager());
+    return JsonVariantConst(data_, resources_);
   }
 
   // Returns true if the reference is unbound.
   // https://arduinojson.org/v7/api/jsonarray/isnull/
   bool isNull() const {
-    return impl_.isNull();
+    return !data_ || !data_->isArray();
   }
 
   // Returns true if the reference is bound.
@@ -167,13 +170,13 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
   // Returns the depth (nesting level) of the array.
   // https://arduinojson.org/v7/api/jsonarray/nesting/
   size_t nesting() const {
-    return impl_.nesting();
+    return detail::VariantData::nesting(data_, resources_);
   }
 
   // Returns the number of elements in the array.
   // https://arduinojson.org/v7/api/jsonarray/size/
   size_t size() const {
-    return impl_.size();
+    return data_ ? data_->size(resources_) : 0;
   }
 
   // DEPRECATED: use add<JsonVariant>() instead
@@ -200,40 +203,19 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
 
  private:
   detail::ResourceManager* getResourceManager() const {
-    return impl_.resources();
+    return resources_;
   }
 
   detail::VariantData* getData() const {
-    return impl_.data();
+    return data_;
   }
 
   detail::VariantData* getOrCreateData() const {
-    return impl_.data();
+    return data_;
   }
 
-  // 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_;
+  detail::VariantData* data_;
+  detail::ResourceManager* resources_;
 };
 
 ARDUINOJSON_END_PUBLIC_NAMESPACE

src/ArduinoJson/Array/JsonArrayConst.hpp

@@ -24,7 +24,10 @@ 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 {
-    return iterator(impl_.createIterator(), impl_.resources());
+    auto array = detail::VariantData::asArray(data_);
+    if (!array)
+      return iterator();
+    return iterator(array->createIterator(resources_), resources_);
   }
 
   // Returns an iterator to the element following the last element of the array.
@@ -34,21 +37,21 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
   }
 
   // Creates an unbound reference.
-  JsonArrayConst() {}
+  JsonArrayConst() : data_(0), resources_(0) {}
 
   // INTERNAL USE ONLY
-  JsonArrayConst(detail::VariantData* data, detail::ResourceManager* resources)
-      : impl_(data, resources) {}
-
-  // INTERNAL USE ONLY
-  JsonArrayConst(const detail::VariantImpl& impl) : impl_(impl) {}
+  JsonArrayConst(const detail::VariantData* data,
+                 const detail::ResourceManager* resources)
+      : data_(data), resources_(resources) {}
 
   // 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(impl_.getElement(size_t(index)), impl_.resources());
+    return JsonVariantConst(
+        detail::VariantData::getElement(data_, size_t(index), resources_),
+        resources_);
   }
 
   // Returns the element at the specified index.
@@ -63,13 +66,13 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
   }
 
   operator JsonVariantConst() const {
-    return JsonVariantConst(impl_.data(), impl_.resources());
+    return JsonVariantConst(getData(), resources_);
   }
 
   // Returns true if the reference is unbound.
   // https://arduinojson.org/v7/api/jsonarrayconst/isnull/
   bool isNull() const {
-    return impl_.isNull();
+    return !data_ || !data_->isArray();
   }
 
   // Returns true if the reference is bound.
@@ -81,13 +84,13 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
   // Returns the depth (nesting level) of the array.
   // https://arduinojson.org/v7/api/jsonarrayconst/nesting/
   size_t nesting() const {
-    return impl_.nesting();
+    return detail::VariantData::nesting(getData(), resources_);
   }
 
   // Returns the number of elements in the array.
   // https://arduinojson.org/v7/api/jsonarrayconst/size/
   size_t size() const {
-    return impl_.size();
+    return data_ ? data_->size(resources_) : 0;
   }
 
   // DEPRECATED: always returns zero
@@ -98,10 +101,11 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
 
  private:
   const detail::VariantData* getData() const {
-    return impl_.data();
+    return data_;
   }
 
-  detail::VariantImpl impl_;
+  const detail::VariantData* data_;
+  const detail::ResourceManager* resources_;
 };
 
 // Compares the content of two arrays.

src/ArduinoJson/Array/JsonArrayIterator.hpp

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

src/ArduinoJson/Collection/CollectionData.hpp

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

@@ -1,68 +0,0 @@
-// 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/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,6 +11,7 @@
 #include <ArduinoJson/Object/MemberProxy.hpp>
 #include <ArduinoJson/Polyfills/utility.hpp>
 #include <ArduinoJson/Variant/JsonVariantConst.hpp>
+#include <ArduinoJson/Variant/VariantTo.hpp>
 
 ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
 
@@ -87,7 +88,7 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
   // https://arduinojson.org/v7/api/jsondocument/clear/
   void clear() {
     resources_.clear();
-    data_.type = detail::VariantType::Null;
+    data_.reset();
   }
 
   // Returns true if the root is of the specified type.
@@ -119,13 +120,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 getVariantImpl().nesting();
+    return data_.nesting(&resources_);
   }
 
   // Returns the number of elements in the root array or object.
   // https://arduinojson.org/v7/api/jsondocument/size/
   size_t size() const {
-    return getVariantImpl().size();
+    return data_.size(&resources_);
   }
 
   // Copies the specified document.
@@ -145,38 +146,18 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
 
   // Replaces the root with the specified value.
   // https://arduinojson.org/v7/api/jsondocument/set/
-  template <typename TChar>
+  template <typename TChar,
+            detail::enable_if_t<!detail::is_const<TChar>::value, int> = 0>
   bool set(TChar* src) {
     return to<JsonVariant>().set(src);
   }
 
-  // Sets the document to an empty array.
+  // Clears the document and converts it to the specified type.
   // https://arduinojson.org/v7/api/jsondocument/to/
-  template <typename T,
-            detail::enable_if_t<detail::is_same<T, JsonArray>::value, int> = 0>
-  JsonArray to() {
+  template <typename T>
+  typename detail::VariantTo<T>::type to() {
     clear();
-    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_);
+    return getVariant().template to<T>();
   }
 
   // DEPRECATED: use obj["key"].is<T>() instead
@@ -184,7 +165,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 getVariantImpl().getMember(detail::adaptString(key)) != 0;
+    return data_.getMember(detail::adaptString(key), &resources_) != 0;
   }
 
   // DEPRECATED: use obj[key].is<T>() instead
@@ -193,7 +174,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 getVariantImpl().getMember(detail::adaptString(key)) != 0;
+    return data_.getMember(detail::adaptString(key), &resources_) != 0;
   }
 
   // DEPRECATED: use obj[key].is<T>() instead
@@ -217,7 +198,9 @@ 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, int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
   detail::MemberProxy<JsonDocument&, detail::AdaptedString<TChar*>> operator[](
       TChar* key) {
     return {*this, detail::adaptString(key)};
@@ -229,16 +212,18 @@ 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(
-        getVariantImpl().getMember(detail::adaptString(key)), &resources_);
+        data_.getMember(detail::adaptString(key), &resources_), &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, int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
   JsonVariantConst operator[](TChar* key) const {
     return JsonVariantConst(
-        getVariantImpl().getMember(detail::adaptString(key)), &resources_);
+        data_.getMember(detail::adaptString(key), &resources_), &resources_);
   }
 
   // Gets or sets a root array's element.
@@ -252,7 +237,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(getVariantImpl().getElement(index), &resources_);
+    return JsonVariantConst(data_.getElement(index, &resources_), &resources_);
   }
 
   // Gets or sets a root object's member.
@@ -282,21 +267,22 @@ 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 getOrCreateArray().add<T>();
+    return JsonVariant(data_.addElement(&resources_), &resources_);
   }
 
   // Appends a value to the root array.
   // https://arduinojson.org/v7/api/jsondocument/add/
   template <typename TValue>
   bool add(const TValue& value) {
-    return getOrCreateArray().add(value);
+    return data_.addValue(value, &resources_);
   }
 
   // Appends a value to the root array.
   // https://arduinojson.org/v7/api/jsondocument/add/
-  template <typename TChar>
+  template <typename TChar,
+            detail::enable_if_t<!detail::is_const<TChar>::value, int> = 0>
   bool add(TChar* value) {
-    return getOrCreateArray().add(value);
+    return data_.addValue(value, &resources_);
   }
 
   // Removes an element of the root array.
@@ -304,15 +290,19 @@ 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) {
-    getVariantImpl().removeElement(size_t(index));
+    detail::VariantData::removeElement(getData(), size_t(index),
+                                       getResourceManager());
   }
 
   // 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, int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
   void remove(TChar* key) {
-    getVariantImpl().removeMember(detail::adaptString(key));
+    detail::VariantData::removeMember(getData(), detail::adaptString(key),
+                                      getResourceManager());
   }
 
   // Removes a member of the root object.
@@ -320,7 +310,8 @@ 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) {
-    getVariantImpl().removeMember(detail::adaptString(key));
+    detail::VariantData::removeMember(getData(), detail::adaptString(key),
+                                      getResourceManager());
   }
 
   // Removes a member of the root object or an element of the root array.
@@ -400,16 +391,6 @@ 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_);
   }
@@ -434,12 +415,12 @@ class JsonDocument : public detail::VariantOperators<const JsonDocument&> {
     return &data_;
   }
 
-  mutable detail::ResourceManager resources_;
-  mutable detail::VariantData data_;
+  detail::ResourceManager resources_;
+  detail::VariantData data_;
 };
 
-inline bool convertToJson(const JsonDocument& src, JsonVariant dst) {
-  return dst.set(src.as<JsonVariantConst>());
+inline void convertToJson(const JsonDocument& src, JsonVariant dst) {
+  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, filter, nestingLimit);
+          return parseArray(variant.toArray(), filter, nestingLimit);
         else
           return skipArray(nestingLimit);
 
       case '{':
         if (filter.allowObject())
-          return parseObject(variant, filter, nestingLimit);
+          return parseObject(variant.toObject(), 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,12 +146,10 @@ class JsonDeserializer {
 
   template <typename TFilter>
   DeserializationError::Code parseArray(
-      VariantData* array, TFilter filter,
+      ArrayData& array, TFilter filter,
       DeserializationOption::NestingLimit nestingLimit) {
     DeserializationError::Code err;
 
-    array->toArray();
-
     if (nestingLimit.reached())
       return DeserializationError::TooDeep;
 
@@ -174,12 +172,12 @@ class JsonDeserializer {
     for (;;) {
       if (elementFilter.allow()) {
         // Allocate slot in array
-        VariantData* value = VariantImpl::addNewElement(array, resources_);
+        VariantData* value = array.addElement(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 {
@@ -234,12 +232,10 @@ class JsonDeserializer {
 
   template <typename TFilter>
   DeserializationError::Code parseObject(
-      VariantData* object, TFilter filter,
+      ObjectData& object, TFilter filter,
       DeserializationOption::NestingLimit nestingLimit) {
     DeserializationError::Code err;
 
-    object->toObject();
-
     if (nestingLimit.reached())
       return DeserializationError::TooDeep;
 
@@ -277,20 +273,19 @@ class JsonDeserializer {
       TFilter memberFilter = filter[key];
 
       if (memberFilter.allow()) {
-        auto member =
-            VariantImpl::getMember(adaptString(key), object, resources_);
+        auto member = object.getMember(adaptString(key), resources_);
         if (!member) {
-          auto keyVariant = VariantImpl::addPair(&member, object, resources_);
+          auto keyVariant = object.addPair(&member, resources_);
           if (!keyVariant)
             return DeserializationError::NoMemory;
 
           stringBuilder_.save(keyVariant);
         } else {
-          VariantImpl::clear(member, resources_);
+          member->clear(resources_);
         }
 
         // Parse value
-        err = parseVariant(member, memberFilter, nestingLimit.decrement());
+        err = parseVariant(*member, memberFilter, nestingLimit.decrement());
         if (err)
           return err;
       } else {
@@ -384,7 +379,7 @@ class JsonDeserializer {
     }
   }
 
-  DeserializationError::Code parseStringValue(VariantData* variant) {
+  DeserializationError::Code parseStringValue(VariantData& variant) {
     DeserializationError::Code err;
 
     stringBuilder_.startString();
@@ -393,7 +388,7 @@ class JsonDeserializer {
     if (err)
       return err;
 
-    stringBuilder_.save(variant);
+    stringBuilder_.save(&variant);
 
     return DeserializationError::Ok;
   }
@@ -509,7 +504,7 @@ class JsonDeserializer {
     return DeserializationError::Ok;
   }
 
-  DeserializationError::Code parseNumericValue(VariantData* result) {
+  DeserializationError::Code parseNumericValue(VariantData& result) {
     uint8_t n = 0;
 
     char c = current();
@@ -523,28 +518,26 @@ class JsonDeserializer {
     auto number = parseNumber(buffer_);
     switch (number.type()) {
       case NumberType::UnsignedInteger:
-        if (VariantImpl::setInteger(number.asUnsignedInteger(), result,
-                                    resources_))
+        if (result.setInteger(number.asUnsignedInteger(), resources_))
           return DeserializationError::Ok;
         else
           return DeserializationError::NoMemory;
 
       case NumberType::SignedInteger:
-        if (VariantImpl::setInteger(number.asSignedInteger(), result,
-                                    resources_))
+        if (result.setInteger(number.asSignedInteger(), resources_))
           return DeserializationError::Ok;
         else
           return DeserializationError::NoMemory;
 
       case NumberType::Float:
-        if (VariantImpl::setFloat(number.asFloat(), result, resources_))
+        if (result.setFloat(number.asFloat(), resources_))
           return DeserializationError::Ok;
         else
           return DeserializationError::NoMemory;
 
 #if ARDUINOJSON_USE_DOUBLE
       case NumberType::Double:
-        if (VariantImpl::setFloat(number.asDouble(), result, resources_))
+        if (result.setFloat(number.asDouble(), resources_))
           return DeserializationError::Ok;
         else
           return DeserializationError::NoMemory;

src/ArduinoJson/Json/JsonSerializer.hpp

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

src/ArduinoJson/Json/PrettyJsonSerializer.hpp

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

src/ArduinoJson/Json/TextFormatter.hpp

@@ -66,16 +66,13 @@ class TextFormatter {
 
   template <typename T>
   void writeFloat(T value) {
-    writeFloat(JsonFloat(value), sizeof(T) >= 8 ? 9 : 7);
+    writeFloat(JsonFloat(value), sizeof(T) >= 8 ? 9 : 6);
   }
 
   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('-');
@@ -96,28 +93,9 @@ class TextFormatter {
 
     auto parts = decomposeFloat(value, 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);
+    writeInteger(parts.integral);
+    if (parts.decimalPlaces)
+      writeDecimals(parts.decimal, parts.decimalPlaces);
 
     if (parts.exponent) {
       writeRaw('e');
@@ -154,6 +132,23 @@ 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/MemoryPool.hpp

@@ -34,6 +34,11 @@ class Slot {
     return ptr_;
   }
 
+  T& operator*() const {
+    ARDUINOJSON_ASSERT(ptr_ != nullptr);
+    return *ptr_;
+  }
+
   T* operator->() const {
     ARDUINOJSON_ASSERT(ptr_ != nullptr);
     return ptr_;
@@ -76,6 +81,14 @@ class MemoryPool {
     return slots_ + id;
   }
 
+  SlotId find(const T& value) const {
+    for (SlotId i = 0; i < usage_; i++) {
+      if (slots_[i] == value)
+        return i;
+    }
+    return NULL_SLOT;
+  }
+
   void clear() {
     usage_ = 0;
   }

src/ArduinoJson/Memory/MemoryPoolList.hpp

@@ -114,6 +114,15 @@ class MemoryPoolList {
     return pools_[poolIndex].getSlot(indexInPool);
   }
 
+  SlotId find(const T& value) const {
+    for (PoolCount i = 0; i < count_; i++) {
+      SlotId id = pools_[i].find(value);
+      if (id != NULL_SLOT)
+        return SlotId(i * ARDUINOJSON_POOL_CAPACITY + id);
+    }
+    return NULL_SLOT;
+  }
+
   void clear(Allocator* allocator) {
     for (PoolCount i = 0; i < count_; i++)
       pools_[i].destroy(allocator);

src/ArduinoJson/Memory/ResourceManager.hpp

@@ -14,6 +14,7 @@
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
+class VariantData;
 class VariantWithId;
 
 class ResourceManager {
@@ -24,6 +25,7 @@ class ResourceManager {
   ~ResourceManager() {
     stringPool_.clear(allocator_);
     variantPools_.clear(allocator_);
+    staticStringsPools_.clear(allocator_);
 #if ARDUINOJSON_USE_8_BYTE_POOL
     eightBytePools_.clear(allocator_);
 #endif
@@ -35,6 +37,7 @@ class ResourceManager {
   friend void swap(ResourceManager& a, ResourceManager& b) {
     swap(a.stringPool_, b.stringPool_);
     swap(a.variantPools_, b.variantPools_);
+    swap(a.staticStringsPools_, b.staticStringsPools_);
 #if ARDUINOJSON_USE_8_BYTE_POOL
     swap(a.eightBytePools_, b.eightBytePools_);
 #endif
@@ -54,43 +57,14 @@ class ResourceManager {
     return overflowed_;
   }
 
-  Slot<VariantData> allocVariant() {
-    auto slot = variantPools_.allocSlot(allocator_);
-    if (!slot) {
-      overflowed_ = true;
-      return {};
-    }
-    new (slot.ptr()) VariantData();
-    return slot;
-  }
-
-  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));
-  }
+  Slot<VariantData> allocVariant();
+  void freeVariant(Slot<VariantData> slot);
+  VariantData* getVariant(SlotId id) const;
 
 #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);
-  }
+  Slot<EightByteValue> allocEightByte();
+  void freeEightByte(SlotId slot);
+  EightByteValue* getEightByte(SlotId id) const;
 #endif
 
   template <typename TAdaptedString>
@@ -136,10 +110,29 @@ class ResourceManager {
     stringPool_.dereference(s, allocator_);
   }
 
+  SlotId saveStaticString(const char* s) {
+    auto existingSlotId = staticStringsPools_.find(s);
+    if (existingSlotId != NULL_SLOT)
+      return existingSlotId;
+
+    auto slot = staticStringsPools_.allocSlot(allocator_);
+    if (slot)
+      *slot = s;
+    else
+      overflowed_ = true;
+
+    return slot.id();
+  }
+
+  const char* getStaticString(SlotId id) const {
+    return *staticStringsPools_.getSlot(id);
+  }
+
   void clear() {
-    variantPools_.clear(allocator_);
     overflowed_ = false;
+    variantPools_.clear(allocator_);
     stringPool_.clear(allocator_);
+    staticStringsPools_.clear(allocator_);
 #if ARDUINOJSON_USE_8_BYTE_POOL
     eightBytePools_.clear(allocator_);
 #endif
@@ -147,6 +140,7 @@ class ResourceManager {
 
   void shrinkToFit() {
     variantPools_.shrinkToFit(allocator_);
+    staticStringsPools_.shrinkToFit(allocator_);
 #if ARDUINOJSON_USE_8_BYTE_POOL
     eightBytePools_.shrinkToFit(allocator_);
 #endif
@@ -157,6 +151,7 @@ class ResourceManager {
   bool overflowed_;
   StringPool stringPool_;
   MemoryPoolList<VariantData> variantPools_;
+  MemoryPoolList<const char*> staticStringsPools_;
 #if ARDUINOJSON_USE_8_BYTE_POOL
   MemoryPoolList<EightByteValue> eightBytePools_;
 #endif

src/ArduinoJson/Memory/ResourceManagerImpl.hpp

@@ -0,0 +1,53 @@
+// 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 slot = variantPools_.allocSlot(allocator_);
+  if (!slot) {
+    overflowed_ = true;
+    return {};
+  }
+  new (slot.ptr()) VariantData();
+  return slot;
+}
+
+inline void ResourceManager::freeVariant(Slot<VariantData> slot) {
+  slot->clear(this);
+  variantPools_.freeSlot(slot);
+}
+
+inline VariantData* ResourceManager::getVariant(SlotId id) const {
+  return reinterpret_cast<VariantData*>(variantPools_.getSlot(id));
+}
+
+#if ARDUINOJSON_USE_8_BYTE_POOL
+inline Slot<EightByteValue> ResourceManager::allocEightByte() {
+  auto slot = eightBytePools_.allocSlot(allocator_);
+  if (!slot) {
+    overflowed_ = true;
+    return {};
+  }
+  return slot;
+}
+
+inline void ResourceManager::freeEightByte(SlotId id) {
+  auto p = getEightByte(id);
+  eightBytePools_.freeSlot({p, id});
+}
+
+inline EightByteValue* ResourceManager::getEightByte(SlotId id) const {
+  return eightBytePools_.getSlot(id);
+}
+#endif
+
+ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Memory/StringBuffer.hpp

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

src/ArduinoJson/Memory/StringBuilder.hpp

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

src/ArduinoJson/MsgPack/MsgPackBinary.hpp

@@ -24,48 +24,45 @@ class MsgPackBinary {
 
 template <>
 struct Converter<MsgPackBinary> : private detail::VariantAttorney {
-  static bool toJson(MsgPackBinary src, JsonVariant dst) {
+  static void toJson(MsgPackBinary src, JsonVariant dst) {
     auto data = VariantAttorney::getData(dst);
     if (!data)
-      return false;
-
+      return;
     auto resources = getResourceManager(dst);
-    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);
+    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;
+      }
     }
-    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)
-        VariantImpl::setInteger(static_cast<int8_t>(code), variant, resources_);
+        variant->setInteger(static_cast<int8_t>(code), resources_);
       return DeserializationError::Ok;
     }
 
@@ -231,14 +231,14 @@ class MsgPackDeserializer {
     if (isSigned) {
       auto truncatedValue = static_cast<JsonInteger>(signedValue);
       if (truncatedValue == signedValue) {
-        if (!VariantImpl::setInteger(truncatedValue, variant, resources_))
+        if (!variant->setInteger(truncatedValue, resources_))
           return DeserializationError::NoMemory;
       }
       // else set null on overflow
     } else {
       auto truncatedValue = static_cast<JsonUInt>(unsignedValue);
       if (truncatedValue == unsignedValue)
-        if (!VariantImpl::setInteger(truncatedValue, variant, resources_))
+        if (!variant->setInteger(truncatedValue, resources_))
           return DeserializationError::NoMemory;
       // else set null on overflow
     }
@@ -257,7 +257,7 @@ class MsgPackDeserializer {
       return err;
 
     fixEndianness(value);
-    VariantImpl::setFloat(value, variant, resources_);
+    variant->setFloat(value, resources_);
 
     return DeserializationError::Ok;
   }
@@ -273,7 +273,7 @@ class MsgPackDeserializer {
       return err;
 
     fixEndianness(value);
-    if (VariantImpl::setFloat(value, variant, resources_))
+    if (variant->setFloat(value, resources_))
       return DeserializationError::Ok;
     else
       return DeserializationError::NoMemory;
@@ -293,7 +293,7 @@ class MsgPackDeserializer {
 
     doubleToFloat(i, o);
     fixEndianness(value);
-    VariantImpl::setFloat(value, variant, resources_);
+    variant->setFloat(value, resources_);
 
     return DeserializationError::Ok;
   }
@@ -349,9 +349,12 @@ class MsgPackDeserializer {
 
     bool allowArray = filter.allowArray();
 
+    ArrayData* array;
     if (allowArray) {
       ARDUINOJSON_ASSERT(variant != 0);
-      variant->toArray();
+      array = &variant->toArray();
+    } else {
+      array = 0;
     }
 
     TFilter elementFilter = filter[0U];
@@ -360,7 +363,8 @@ class MsgPackDeserializer {
       VariantData* value;
 
       if (elementFilter.allow()) {
-        value = VariantImpl::addNewElement(variant, resources_);
+        ARDUINOJSON_ASSERT(array != 0);
+        value = array->addElement(resources_);
         if (!value)
           return DeserializationError::NoMemory;
       } else {
@@ -384,9 +388,12 @@ class MsgPackDeserializer {
     if (nestingLimit.reached())
       return DeserializationError::TooDeep;
 
+    ObjectData* object;
     if (filter.allowObject()) {
       ARDUINOJSON_ASSERT(variant != 0);
-      variant->toObject();
+      object = &variant->toObject();
+    } else {
+      object = 0;
     }
 
     for (; n; --n) {
@@ -399,7 +406,9 @@ class MsgPackDeserializer {
       VariantData* member = 0;
 
       if (memberFilter.allow()) {
-        auto keyVariant = VariantImpl::addPair(&member, variant, resources_);
+        ARDUINOJSON_ASSERT(object != 0);
+
+        auto keyVariant = object->addPair(&member, resources_);
         if (!keyVariant)
           return DeserializationError::NoMemory;
 

src/ArduinoJson/MsgPack/MsgPackExtension.hpp

@@ -30,57 +30,53 @@ class MsgPackExtension {
 
 template <>
 struct Converter<MsgPackExtension> : private detail::VariantAttorney {
-  static bool toJson(MsgPackExtension src, JsonVariant dst) {
-    auto data = getData(dst);
+  static void toJson(MsgPackExtension src, JsonVariant dst) {
+    auto data = VariantAttorney::getData(dst);
     if (!data)
-      return false;
-
+      return;
     auto resources = getResourceManager(dst);
-    detail::VariantImpl::clear(data, resources);
+    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;
+      }
 
-    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) {
+        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 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, ResourceManager* resources)
+  MsgPackSerializer(TWriter writer, const ResourceManager* resources)
       : writer_(writer), resources_(resources) {}
 
   template <typename T>
@@ -47,11 +47,8 @@ class MsgPackSerializer : public VariantDataVisitor<size_t> {
     return bytesWritten();
   }
 
-  size_t visitArray(VariantData* array) {
-    ARDUINOJSON_ASSERT(array != nullptr);
-    ARDUINOJSON_ASSERT(array->isArray());
-
-    auto n = VariantImpl::size(array, resources_);
+  size_t visit(const ArrayData& array) {
+    size_t n = array.size(resources_);
     if (n < 0x10) {
       writeByte(uint8_t(0x90 + n));
     } else if (n < 0x10000) {
@@ -62,21 +59,18 @@ class MsgPackSerializer : public VariantDataVisitor<size_t> {
       writeInteger(uint32_t(n));
     }
 
-    auto slotId = array->content.asCollection.head;
+    auto slotId = array.head();
     while (slotId != NULL_SLOT) {
       auto slot = resources_->getVariant(slotId);
-      VariantImpl::accept(*this, slot, resources_);
-      slotId = slot->next;
+      slot->accept(*this, resources_);
+      slotId = slot->next();
     }
 
     return bytesWritten();
   }
 
-  size_t visitObject(VariantData* object) {
-    ARDUINOJSON_ASSERT(object != nullptr);
-    ARDUINOJSON_ASSERT(object->isObject());
-
-    auto n = VariantImpl::size(object, resources_);
+  size_t visit(const ObjectData& object) {
+    size_t n = object.size(resources_);
     if (n < 0x10) {
       writeByte(uint8_t(0x80 + n));
     } else if (n < 0x10000) {
@@ -87,11 +81,11 @@ class MsgPackSerializer : public VariantDataVisitor<size_t> {
       writeInteger(uint32_t(n));
     }
 
-    auto slotId = object->content.asCollection.head;
+    auto slotId = object.head();
     while (slotId != NULL_SLOT) {
       auto slot = resources_->getVariant(slotId);
-      VariantImpl::accept(*this, slot, resources_);
-      slotId = slot->next;
+      slot->accept(*this, resources_);
+      slotId = slot->next();
     }
 
     return bytesWritten();
@@ -215,7 +209,7 @@ class MsgPackSerializer : public VariantDataVisitor<size_t> {
   }
 
   CountingDecorator<TWriter> writer_;
-  ResourceManager* resources_;
+  const ResourceManager* resources_;
 };
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Numbers/FloatParts.hpp

@@ -7,86 +7,89 @@
 #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 mantissa;
+  uint32_t integral;
+  uint32_t decimal;
   int16_t exponent;
-  int8_t pointIndex;
+  int8_t decimalPlaces;
 };
 
+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 significantDigits) {
-  ARDUINOJSON_ASSERT(value > 0);
-  ARDUINOJSON_ASSERT(significantDigits > 1);
-  ARDUINOJSON_ASSERT(significantDigits <= 9);  // to prevent uint32_t overflow
+inline FloatParts decomposeFloat(JsonFloat value, int8_t decimalPlaces) {
+  uint32_t maxDecimalPart = pow10(decimalPlaces);
 
-  using traits = FloatTraits<JsonFloat>;
+  int16_t exponent = normalize(value);
 
-  bool useScientificNotation =
-      value >= ARDUINOJSON_POSITIVE_EXPONENTIATION_THRESHOLD ||
-      value <= ARDUINOJSON_NEGATIVE_EXPONENTIATION_THRESHOLD;
-
-  int16_t exponent = 0;
-  int8_t index = traits::binaryPowersOfTenArraySize - 1;
-  int bit = 1 << index;
-
-  // 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;
-    }
+  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--;
   }
-  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;
+
+  JsonFloat remainder =
+      (value - JsonFloat(integral)) * JsonFloat(maxDecimalPart);
+
+  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;
     }
   }
-  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 (mantissa % 10 == 0 && (useScientificNotation || pointIndex > 0)) {
-    mantissa /= 10;
-    if (pointIndex > 0)
-      pointIndex--;
-    else
-      exponent++;
+  while (decimal % 10 == 0 && decimalPlaces > 0) {
+    decimal /= 10;
+    decimalPlaces--;
   }
 
-  return {mantissa, exponent, pointIndex};
+  return {integral, decimal, exponent, decimalPlaces};
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Numbers/FloatTraits.hpp

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

src/ArduinoJson/Object/JsonObjectConst.hpp

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

src/ArduinoJson/Object/JsonObjectIterator.hpp

@@ -14,7 +14,7 @@ class JsonObjectIterator {
  public:
   JsonObjectIterator() {}
 
-  explicit JsonObjectIterator(detail::VariantImpl::iterator iterator,
+  explicit JsonObjectIterator(detail::ObjectData::iterator iterator,
                               detail::ResourceManager* resources)
       : iterator_(iterator), resources_(resources) {}
 
@@ -34,13 +34,13 @@ class JsonObjectIterator {
   }
 
   JsonObjectIterator& operator++() {
-    iterator_.move(resources_);  // key
-    iterator_.move(resources_);  // value
+    iterator_.next(resources_);  // key
+    iterator_.next(resources_);  // value
     return *this;
   }
 
  private:
-  detail::VariantImpl::iterator iterator_;
+  detail::ObjectData::iterator iterator_;
   detail::ResourceManager* resources_;
 };
 
@@ -50,8 +50,8 @@ class JsonObjectConstIterator {
  public:
   JsonObjectConstIterator() {}
 
-  explicit JsonObjectConstIterator(detail::VariantImpl::iterator iterator,
-                                   detail::ResourceManager* resources)
+  explicit JsonObjectConstIterator(detail::ObjectData::iterator iterator,
+                                   const detail::ResourceManager* resources)
       : iterator_(iterator), resources_(resources) {}
 
   JsonPairConst operator*() const {
@@ -70,14 +70,14 @@ class JsonObjectConstIterator {
   }
 
   JsonObjectConstIterator& operator++() {
-    iterator_.move(resources_);  // key
-    iterator_.move(resources_);  // value
+    iterator_.next(resources_);  // key
+    iterator_.next(resources_);  // value
     return *this;
   }
 
  private:
-  detail::VariantImpl::iterator iterator_;
-  detail::ResourceManager* resources_;
+  detail::ObjectData::iterator iterator_;
+  const 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::VariantImpl::iterator iterator,
+  JsonPair(detail::ObjectData::iterator iterator,
            detail::ResourceManager* resources) {
     if (!iterator.done()) {
-      key_ = iterator->asString();
-      iterator.move(resources);
+      key_ = iterator->asString(resources);
+      iterator.next(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::VariantImpl::iterator iterator,
-                detail::ResourceManager* resources) {
+  JsonPairConst(detail::ObjectData::iterator iterator,
+                const detail::ResourceManager* resources) {
     if (!iterator.done()) {
-      key_ = iterator->asString();
-      iterator.move(resources);
+      key_ = iterator->asString(resources);
+      iterator.next(resources);
       value_ = JsonVariantConst(iterator.data(), resources);
     }
   }

src/ArduinoJson/Object/MemberProxy.hpp

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

src/ArduinoJson/Object/ObjectData.hpp

@@ -0,0 +1,70 @@
+// 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,49 +4,39 @@
 
 #pragma once
 
+#include <ArduinoJson/Object/ObjectData.hpp>
 #include <ArduinoJson/Variant/VariantCompare.hpp>
-#include <ArduinoJson/Variant/VariantImpl.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
 template <typename TAdaptedString>
-inline VariantData* VariantImpl::getMember(TAdaptedString key,
-                                           VariantData* data,
-                                           ResourceManager* resources) {
-  auto it = findKey(key, data, resources);
+inline VariantData* ObjectData::getMember(
+    TAdaptedString key, const ResourceManager* resources) const {
+  auto it = findKey(key, resources);
   if (it.done())
     return nullptr;
-  it.move(resources);
+  it.next(resources);
   return it.data();
 }
 
 template <typename TAdaptedString>
-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);
+VariantData* ObjectData::getOrAddMember(TAdaptedString key,
+                                        ResourceManager* resources) {
+  auto data = getMember(key, resources);
+  if (data)
+    return data;
+  return addMember(key, resources);
 }
 
 template <typename TAdaptedString>
-inline VariantImpl::iterator VariantImpl::findKey(TAdaptedString key,
-                                                  VariantData* data,
-                                                  ResourceManager* resources) {
-  ARDUINOJSON_ASSERT(data != nullptr);
-  ARDUINOJSON_ASSERT(data->isObject());
-  ARDUINOJSON_ASSERT(resources != nullptr);
-
+inline ObjectData::iterator ObjectData::findKey(
+    TAdaptedString key, const ResourceManager* resources) const {
   if (key.isNull())
     return iterator();
   bool isKey = true;
-  for (auto it = createIterator(data, resources); !it.done();
-       it.move(resources)) {
-    if (isKey && stringEquals(key, adaptString(it->asString())))
+  for (auto it = createIterator(resources); !it.done(); it.next(resources)) {
+    if (isKey && stringEquals(key, adaptString(it->asString(resources))))
       return it;
     isKey = !isKey;
   }
@@ -54,16 +44,14 @@ inline VariantImpl::iterator VariantImpl::findKey(TAdaptedString key,
 }
 
 template <typename TAdaptedString>
-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
+inline void ObjectData::removeMember(TAdaptedString key,
+                                     ResourceManager* resources) {
+  remove(findKey(key, resources), resources);
+}
 
+template <typename TAdaptedString>
+inline VariantData* ObjectData::addMember(TAdaptedString key,
+                                          ResourceManager* resources) {
   auto keySlot = resources->allocVariant();
   if (!keySlot)
     return nullptr;
@@ -72,21 +60,16 @@ inline VariantData* VariantImpl::addMember(TAdaptedString key,
   if (!valueSlot)
     return nullptr;
 
-  if (!VariantImpl::setString(key, keySlot.ptr(), resources))
+  if (!keySlot->setString(key, resources))
     return nullptr;
 
-  appendPair(keySlot, valueSlot, data, resources);
+  CollectionData::appendPair(keySlot, valueSlot, resources);
 
   return valueSlot.ptr();
 }
 
-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);
-
+inline VariantData* ObjectData::addPair(VariantData** value,
+                                        ResourceManager* resources) {
   auto keySlot = resources->allocVariant();
   if (!keySlot)
     return nullptr;
@@ -96,7 +79,7 @@ inline VariantData* VariantImpl::addPair(VariantData** value, VariantData* data,
     return nullptr;
   *value = valueSlot.ptr();
 
-  appendPair(keySlot, valueSlot, data, resources);
+  CollectionData::appendPair(keySlot, valueSlot, resources);
 
   return keySlot.ptr();
 }

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 VariantImpl::accept(serializer, data, resources);
+  return VariantData::accept(data, resources, serializer);
 }
 
 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 VariantImpl::accept(serializer, data, resources);
+  return VariantData::accept(data, resources, serializer);
 }
 
 template <template <typename> class TSerializer, typename TDestination>

src/ArduinoJson/Strings/Adapters/FlashString.hpp

@@ -63,6 +63,10 @@ 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,8 +20,14 @@ 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) : str_(str), size_(sz) {
+  RamString(const char* str, size_t sz, bool isStatic = false)
+      : str_(str), size_(sz & sizeMask), static_(isStatic) {
     ARDUINOJSON_ASSERT(size_ == sz);
   }
 
@@ -43,9 +49,21 @@ 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>
@@ -58,6 +76,37 @@ 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) {
+    ARDUINOJSON_ASSERT(p);
+    return RamString(p, ::strlen(p), 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,25 +19,16 @@ class JsonString {
   friend struct detail::StringAdapter<JsonString>;
 
  public:
-  JsonString() : str_(nullptr, 0) {}
+  JsonString() : str_(nullptr, 0, true) {}
 
-  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) {}
+  JsonString(const char* data, bool isStatic = false)
+      : str_(data, data ? ::strlen(data) : 0, isStatic) {}
 
   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) : 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) {}
+  JsonString(const char* data, TSize sz) : str_(data, size_t(sz), false) {}
 
   // Returns a pointer to the characters.
   const char* c_str() const {
@@ -49,10 +40,10 @@ class JsonString {
     return str_.isNull();
   }
 
-  // Deprecated: always returns false.
-  ARDUINOJSON_DEPRECATED("The isStatic() was removed in v7.5")
+  // Returns true if the string is stored by address.
+  // Returns false if the string is stored by copy.
   bool isStatic() const {
-    return false;
+    return str_.isStatic();
   }
 
   // Returns length of the string.

src/ArduinoJson/Strings/StringAdapter.hpp

@@ -8,6 +8,13 @@
 
 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;
 
@@ -15,7 +22,9 @@ template <typename TString, typename Enable = void>
 struct SizedStringAdapter;
 
 template <typename TString>
-using StringAdapterFor = StringAdapter<decay_t<TString>>;
+using StringAdapterFor =
+    StringAdapter<conditional_t<IsStringLiteral<TString>::value, TString,
+                                remove_cv_t<remove_reference_t<TString>>>>;
 
 template <typename T>
 using AdaptedString = typename StringAdapterFor<T>::AdaptedString;
@@ -25,7 +34,7 @@ AdaptedString<TString> adaptString(TString&& s) {
   return StringAdapterFor<TString>::adapt(detail::forward<TString>(s));
 }
 
-template <typename TChar>
+template <typename TChar, enable_if_t<!is_const<TChar>::value, int> = 0>
 AdaptedString<TChar*> adaptString(TChar* p) {
   return StringAdapter<TChar*>::adapt(p);
 }

src/ArduinoJson/Variant/ConverterImpl.hpp

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

src/ArduinoJson/Variant/JsonVariant.hpp

@@ -16,29 +16,27 @@ class JsonVariant : public detail::VariantRefBase<JsonVariant>,
 
  public:
   // Creates an unbound reference.
-  JsonVariant() {}
+  JsonVariant() : data_(0), resources_(0) {}
 
   // INTERNAL USE ONLY
   JsonVariant(detail::VariantData* data, detail::ResourceManager* resources)
-      : impl_(data, resources) {}
-
-  // INTERNAL USE ONLY
-  JsonVariant(detail::VariantImpl impl) : impl_(impl) {}
+      : data_(data), resources_(resources) {}
 
  private:
   detail::ResourceManager* getResourceManager() const {
-    return impl_.resources();
+    return resources_;
   }
 
   detail::VariantData* getData() const {
-    return impl_.data();
+    return data_;
   }
 
   detail::VariantData* getOrCreateData() const {
-    return impl_.data();
+    return data_;
   }
 
-  mutable detail::VariantImpl impl_;
+  detail::VariantData* data_;
+  detail::ResourceManager* resources_;
 };
 
 namespace detail {
@@ -47,8 +45,8 @@ bool copyVariant(JsonVariant dst, JsonVariantConst src);
 
 template <>
 struct Converter<JsonVariant> : private detail::VariantAttorney {
-  static bool toJson(JsonVariantConst src, JsonVariant dst) {
-    return copyVariant(dst, src);
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
+    copyVariant(dst, src);
   }
 
   static JsonVariant fromJson(JsonVariant src) {
@@ -63,8 +61,8 @@ struct Converter<JsonVariant> : private detail::VariantAttorney {
 
 template <>
 struct Converter<JsonVariantConst> : private detail::VariantAttorney {
-  static bool toJson(JsonVariantConst src, JsonVariant dst) {
-    return copyVariant(dst, src);
+  static void toJson(JsonVariantConst src, JsonVariant dst) {
+    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() {}
+  JsonVariantConst() : data_(nullptr), resources_(nullptr) {}
 
   // INTERNAL USE ONLY
-  explicit JsonVariantConst(detail::VariantData* data,
-                            detail::ResourceManager* resources)
-      : impl_(data, resources) {}
+  explicit JsonVariantConst(const detail::VariantData* data,
+                            const detail::ResourceManager* resources)
+      : data_(data), resources_(resources) {}
 
   // Returns true if the value is null or the reference is unbound.
   // https://arduinojson.org/v7/api/jsonvariantconst/isnull/
   bool isNull() const {
-    return impl_.isNull();
+    return detail::VariantData::isNull(data_);
   }
 
   // Returns true if the reference is unbound.
   bool isUnbound() const {
-    return impl_.data() == nullptr;
+    return !data_;
   }
 
   // Returns the depth (nesting level) of the value.
   // https://arduinojson.org/v7/api/jsonvariantconst/nesting/
   size_t nesting() const {
-    return impl_.nesting();
+    return detail::VariantData::nesting(data_, resources_);
   }
 
   // Returns the size of the array or object.
   // https://arduinojson.org/v7/api/jsonvariantconst/size/
   size_t size() const {
-    return impl_.size();
+    return detail::VariantData::size(data_, resources_);
   }
 
   // Casts the value to the specified type.
@@ -104,7 +104,9 @@ 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(impl_.getElement(size_t(index)), impl_.resources());
+    return JsonVariantConst(
+        detail::VariantData::getElement(data_, size_t(index), resources_),
+        resources_);
   }
 
   // Gets object's member with specified key.
@@ -112,17 +114,21 @@ 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(impl_.getMember(detail::adaptString(key)),
-                            impl_.resources());
+    return JsonVariantConst(detail::VariantData::getMember(
+                                data_, detail::adaptString(key), resources_),
+                            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, int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
   JsonVariantConst operator[](TChar* key) const {
-    return JsonVariantConst(impl_.getMember(detail::adaptString(key)),
-                            impl_.resources());
+    return JsonVariantConst(detail::VariantData::getMember(
+                                data_, detail::adaptString(key), resources_),
+                            resources_);
   }
 
   // Gets object's member with specified key or the array's element at the
@@ -143,16 +149,20 @@ 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 impl_.getMember(detail::adaptString(key)) != 0;
+    return detail::VariantData::getMember(getData(), detail::adaptString(key),
+                                          resources_) != 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, int> = 0>
+            detail::enable_if_t<detail::IsString<TChar*>::value &&
+                                    !detail::is_const<TChar>::value,
+                                int> = 0>
   ARDUINOJSON_DEPRECATED("use obj[\"key\"].is<T>() instead")
   bool containsKey(TChar* key) const {
-    return impl_.getMember(detail::adaptString(key)) != 0;
+    return detail::VariantData::getMember(getData(), detail::adaptString(key),
+                                          resources_) != 0;
   }
 
   // DEPRECATED: use obj[key].is<T>() instead
@@ -171,16 +181,17 @@ class JsonVariantConst : public detail::VariantTag,
   }
 
  protected:
-  detail::VariantData* getData() const {
-    return impl_.data();
+  const detail::VariantData* getData() const {
+    return data_;
   }
 
-  detail::ResourceManager* getResourceManager() const {
-    return impl_.resources();
+  const detail::ResourceManager* getResourceManager() const {
+    return resources_;
   }
 
  private:
-  mutable detail::VariantImpl impl_;
+  const detail::VariantData* data_;
+  const detail::ResourceManager* resources_;
 };
 
 ARDUINOJSON_END_PUBLIC_NAMESPACE

src/ArduinoJson/Variant/JsonVariantVisitor.hpp

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

src/ArduinoJson/Variant/VariantAttorney.hpp

@@ -6,7 +6,8 @@
 
 #include <ArduinoJson/Polyfills/attributes.hpp>
 #include <ArduinoJson/Polyfills/type_traits.hpp>
-#include <ArduinoJson/Variant/VariantImpl.hpp>
+#include <ArduinoJson/Variant/VariantData.hpp>
+#include <ArduinoJson/Variant/VariantTo.hpp>
 #include "JsonVariantConst.hpp"
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
@@ -25,16 +26,6 @@ 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,8 +6,10 @@
 
 #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
 
@@ -21,14 +23,15 @@ enum class VariantTypeBits : uint8_t {
 };
 
 enum class VariantType : uint8_t {
-  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
+  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
 #if ARDUINOJSON_USE_LONG_LONG
   Uint64 = 0x1A,  // 0001 1010
   Int64 = 0x1C,   // 0001 1100
@@ -44,18 +47,6 @@ 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 {
@@ -65,11 +56,11 @@ union VariantContent {
   bool asBoolean;
   uint32_t asUint32;
   int32_t asInt32;
-#if ARDUINOJSON_USE_8_BYTE_POOL
   SlotId asSlotId;
-#endif
+  ArrayData asArray;
+  ObjectData asObject;
   CollectionData asCollection;
-  struct StringNode* asStringNode;
+  struct StringNode* asOwnedString;
   char asTinyString[tinyStringMaxLength + 1];
 };
 

src/ArduinoJson/Variant/VariantData.hpp

@@ -4,8 +4,12 @@
 
 #pragma once
 
+#include <ArduinoJson/Memory/MemoryPool.hpp>
 #include <ArduinoJson/Memory/StringNode.hpp>
+#include <ArduinoJson/Misc/SerializedValue.hpp>
+#include <ArduinoJson/Numbers/convertNumber.hpp>
 #include <ArduinoJson/Strings/JsonString.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
 #include <ArduinoJson/Variant/VariantContent.hpp>
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
@@ -23,11 +27,12 @@ static bool isTinyString(const T& s, size_t n) {
   return !containsNul;
 }
 
-struct VariantData {
-  VariantContent content;  // must be first to allow cast from array to variant
-  VariantType type = VariantType::Null;
-  SlotId next = NULL_SLOT;
+class VariantData {
+  VariantContent content_;  // must be first to allow cast from array to variant
+  VariantType type_;
+  SlotId next_;
 
+ public:
   // Placement new
   static void* operator new(size_t, void* p) noexcept {
     return p;
@@ -35,103 +40,584 @@ struct VariantData {
 
   static void operator delete(void*, void*) noexcept {}
 
-  JsonString asRawString() const {
-    switch (type) {
-      case VariantType::RawString:
-        return JsonString(content.asStringNode->data,
-                          content.asStringNode->length);
-      default:
-        return JsonString();
-    }
+  VariantData() : type_(VariantType::Null), next_(NULL_SLOT) {}
+
+  SlotId next() const {
+    return next_;
   }
 
-  JsonString asString() const {
-    switch (type) {
+  void setNext(SlotId slot) {
+    next_ = slot;
+  }
+
+  template <typename TVisitor>
+  typename TVisitor::result_type accept(
+      TVisitor& visit, const ResourceManager* resources) const {
+#if ARDUINOJSON_USE_8_BYTE_POOL
+    auto eightByteValue = getEightByte(resources);
+#else
+    (void)resources;  // silence warning
+#endif
+    switch (type_) {
+      case VariantType::Float:
+        return visit.visit(content_.asFloat);
+
+#if ARDUINOJSON_USE_DOUBLE
+      case VariantType::Double:
+        return visit.visit(eightByteValue->asDouble);
+#endif
+
+      case VariantType::Array:
+        return visit.visit(content_.asArray);
+
+      case VariantType::Object:
+        return visit.visit(content_.asObject);
+
       case VariantType::TinyString:
-        return JsonString(content.asTinyString);
-      case VariantType::LongString:
-        return JsonString(content.asStringNode->data,
-                          content.asStringNode->length);
+        return visit.visit(JsonString(content_.asTinyString));
+
+      case VariantType::LinkedString:
+        return visit.visit(JsonString(asLinkedString(resources), true));
+
+      case VariantType::OwnedString:
+        return visit.visit(JsonString(content_.asOwnedString->data,
+                                      content_.asOwnedString->length));
+
+      case VariantType::RawString:
+        return visit.visit(RawString(content_.asOwnedString->data,
+                                     content_.asOwnedString->length));
+
+      case VariantType::Int32:
+        return visit.visit(static_cast<JsonInteger>(content_.asInt32));
+
+      case VariantType::Uint32:
+        return visit.visit(static_cast<JsonUInt>(content_.asUint32));
+
+#if ARDUINOJSON_USE_LONG_LONG
+      case VariantType::Int64:
+        return visit.visit(eightByteValue->asInt64);
+
+      case VariantType::Uint64:
+        return visit.visit(eightByteValue->asUint64);
+#endif
+
+      case VariantType::Boolean:
+        return visit.visit(content_.asBoolean != 0);
+
+      default:
+        return visit.visit(nullptr);
+    }
+  }
+
+  template <typename TVisitor>
+  static typename TVisitor::result_type accept(const VariantData* var,
+                                               const ResourceManager* resources,
+                                               TVisitor& visit) {
+    if (var != 0)
+      return var->accept(visit, resources);
+    else
+      return visit.visit(nullptr);
+  }
+
+  VariantData* addElement(ResourceManager* resources) {
+    auto array = isNull() ? &toArray() : asArray();
+    return detail::ArrayData::addElement(array, resources);
+  }
+
+  static VariantData* addElement(VariantData* var, ResourceManager* resources) {
+    if (!var)
+      return nullptr;
+    return var->addElement(resources);
+  }
+
+  template <typename T>
+  bool addValue(const T& value, ResourceManager* resources) {
+    auto array = isNull() ? &toArray() : asArray();
+    return detail::ArrayData::addValue(array, value, resources);
+  }
+
+  template <typename T>
+  static bool addValue(VariantData* var, const T& value,
+                       ResourceManager* resources) {
+    if (!var)
+      return false;
+    return var->addValue(value, resources);
+  }
+
+  bool asBoolean(const ResourceManager* resources) const {
+#if ARDUINOJSON_USE_8_BYTE_POOL
+    auto eightByteValue = getEightByte(resources);
+#else
+    (void)resources;  // silence warning
+#endif
+    switch (type_) {
+      case VariantType::Boolean:
+        return content_.asBoolean;
+      case VariantType::Uint32:
+      case VariantType::Int32:
+        return content_.asUint32 != 0;
+      case VariantType::Float:
+        return content_.asFloat != 0;
+#if ARDUINOJSON_USE_DOUBLE
+      case VariantType::Double:
+        return eightByteValue->asDouble != 0;
+#endif
+      case VariantType::Null:
+        return false;
+#if ARDUINOJSON_USE_LONG_LONG
+      case VariantType::Uint64:
+      case VariantType::Int64:
+        return eightByteValue->asUint64 != 0;
+#endif
+      default:
+        return true;
+    }
+  }
+
+  ArrayData* asArray() {
+    return isArray() ? &content_.asArray : 0;
+  }
+
+  const ArrayData* asArray() const {
+    return const_cast<VariantData*>(this)->asArray();
+  }
+
+  static ArrayData* asArray(VariantData* var) {
+    return var ? var->asArray() : 0;
+  }
+
+  static const ArrayData* asArray(const VariantData* var) {
+    return var ? var->asArray() : 0;
+  }
+
+  CollectionData* asCollection() {
+    return isCollection() ? &content_.asCollection : 0;
+  }
+
+  const CollectionData* asCollection() const {
+    return const_cast<VariantData*>(this)->asCollection();
+  }
+
+  template <typename T>
+  T asFloat(const ResourceManager* resources) const {
+    static_assert(is_floating_point<T>::value, "T must be a floating point");
+#if ARDUINOJSON_USE_8_BYTE_POOL
+    auto eightByteValue = getEightByte(resources);
+#else
+    (void)resources;  // silence warning
+#endif
+    const char* str = nullptr;
+    switch (type_) {
+      case VariantType::Boolean:
+        return static_cast<T>(content_.asBoolean);
+      case VariantType::Uint32:
+        return static_cast<T>(content_.asUint32);
+      case VariantType::Int32:
+        return static_cast<T>(content_.asInt32);
+#if ARDUINOJSON_USE_LONG_LONG
+      case VariantType::Uint64:
+        return static_cast<T>(eightByteValue->asUint64);
+      case VariantType::Int64:
+        return static_cast<T>(eightByteValue->asInt64);
+#endif
+      case VariantType::TinyString:
+        str = content_.asTinyString;
+        break;
+      case VariantType::LinkedString:
+        str = asLinkedString(resources);
+        break;
+      case VariantType::OwnedString:
+        str = content_.asOwnedString->data;
+        break;
+      case VariantType::Float:
+        return static_cast<T>(content_.asFloat);
+#if ARDUINOJSON_USE_DOUBLE
+      case VariantType::Double:
+        return static_cast<T>(eightByteValue->asDouble);
+#endif
+      default:
+        return 0.0;
+    }
+
+    ARDUINOJSON_ASSERT(str != nullptr);
+    return parseNumber<T>(str);
+  }
+
+  template <typename T>
+  T asIntegral(const ResourceManager* resources) const {
+    static_assert(is_integral<T>::value, "T must be an integral type");
+#if ARDUINOJSON_USE_8_BYTE_POOL
+    auto eightByteValue = getEightByte(resources);
+#else
+    (void)resources;  // silence warning
+#endif
+    const char* str = nullptr;
+    switch (type_) {
+      case VariantType::Boolean:
+        return content_.asBoolean;
+      case VariantType::Uint32:
+        return convertNumber<T>(content_.asUint32);
+      case VariantType::Int32:
+        return convertNumber<T>(content_.asInt32);
+#if ARDUINOJSON_USE_LONG_LONG
+      case VariantType::Uint64:
+        return convertNumber<T>(eightByteValue->asUint64);
+      case VariantType::Int64:
+        return convertNumber<T>(eightByteValue->asInt64);
+#endif
+      case VariantType::TinyString:
+        str = content_.asTinyString;
+        break;
+      case VariantType::LinkedString:
+        str = asLinkedString(resources);
+        break;
+      case VariantType::OwnedString:
+        str = content_.asOwnedString->data;
+        break;
+      case VariantType::Float:
+        return convertNumber<T>(content_.asFloat);
+#if ARDUINOJSON_USE_DOUBLE
+      case VariantType::Double:
+        return convertNumber<T>(eightByteValue->asDouble);
+#endif
+      default:
+        return 0;
+    }
+
+    ARDUINOJSON_ASSERT(str != nullptr);
+    return parseNumber<T>(str);
+  }
+
+  ObjectData* asObject() {
+    return isObject() ? &content_.asObject : 0;
+  }
+
+  const ObjectData* asObject() const {
+    return const_cast<VariantData*>(this)->asObject();
+  }
+
+  static ObjectData* asObject(VariantData* var) {
+    return var ? var->asObject() : 0;
+  }
+
+  static const ObjectData* asObject(const VariantData* var) {
+    return var ? var->asObject() : 0;
+  }
+
+  JsonString asRawString() const {
+    switch (type_) {
+      case VariantType::RawString:
+        return JsonString(content_.asOwnedString->data,
+                          content_.asOwnedString->length);
       default:
         return JsonString();
     }
   }
 
-  bool isArray() const {
-    return type == VariantType::Array;
+  const char* asLinkedString(const ResourceManager* resources) const;
+
+  JsonString asString(const ResourceManager* resources) const {
+    switch (type_) {
+      case VariantType::TinyString:
+        return JsonString(content_.asTinyString);
+      case VariantType::LinkedString:
+        return JsonString(asLinkedString(resources), true);
+      case VariantType::OwnedString:
+        return JsonString(content_.asOwnedString->data,
+                          content_.asOwnedString->length);
+      default:
+        return JsonString();
+    }
   }
 
-  bool isBoolean() const {
-    return type == VariantType::Boolean;
+#if ARDUINOJSON_USE_8_BYTE_POOL
+  const EightByteValue* getEightByte(const ResourceManager* resources) const;
+#endif
+
+  VariantData* getElement(size_t index,
+                          const ResourceManager* resources) const {
+    return ArrayData::getElement(asArray(), index, resources);
   }
 
-  bool isCollection() const {
-    return type & VariantTypeBits::CollectionMask;
-  }
-
-  bool isFloat() const {
-    return type & VariantTypeBits::NumberBit;
-  }
-
-  bool isNull() const {
-    return type == VariantType::Null;
-  }
-
-  bool isObject() const {
-    return type == VariantType::Object;
-  }
-
-  bool isString() const {
-    return type == VariantType::LongString || type == VariantType::TinyString;
-  }
-
-  void setBoolean(bool value) {
-    ARDUINOJSON_ASSERT(type == VariantType::Null);
-    type = VariantType::Boolean;
-    content.asBoolean = value;
-  }
-
-  void setRawString(StringNode* s) {
-    ARDUINOJSON_ASSERT(type == VariantType::Null);
-    ARDUINOJSON_ASSERT(s);
-    type = VariantType::RawString;
-    content.asStringNode = s;
+  static VariantData* getElement(const VariantData* var, size_t index,
+                                 const ResourceManager* resources) {
+    return var != 0 ? var->getElement(index, resources) : 0;
   }
 
+  template <typename TAdaptedString>
+  VariantData* getMember(TAdaptedString key,
+                         const ResourceManager* resources) const {
+    return ObjectData::getMember(asObject(), key, resources);
+  }
+
+  template <typename TAdaptedString>
+  static VariantData* getMember(const VariantData* var, TAdaptedString key,
+                                const ResourceManager* resources) {
+    if (!var)
+      return 0;
+    return var->getMember(key, resources);
+  }
+
+  VariantData* getOrAddElement(size_t index, ResourceManager* resources) {
+    auto array = isNull() ? &toArray() : asArray();
+    if (!array)
+      return nullptr;
+    return array->getOrAddElement(index, resources);
+  }
+
+  template <typename TAdaptedString>
+  VariantData* getOrAddMember(TAdaptedString key, ResourceManager* resources) {
+    if (key.isNull())
+      return nullptr;
+    auto obj = isNull() ? &toObject() : asObject();
+    if (!obj)
+      return nullptr;
+    return obj->getOrAddMember(key, resources);
+  }
+
+  bool isArray() const {
+    return type_ == VariantType::Array;
+  }
+
+  bool isBoolean() const {
+    return type_ == VariantType::Boolean;
+  }
+
+  bool isCollection() const {
+    return type_ & VariantTypeBits::CollectionMask;
+  }
+
+  bool isFloat() const {
+    return type_ & VariantTypeBits::NumberBit;
+  }
+
+  template <typename T>
+  bool isInteger(const ResourceManager* resources) const {
+#if ARDUINOJSON_USE_LONG_LONG
+    auto eightByteValue = getEightByte(resources);
+#else
+    (void)resources;  // silence warning
+#endif
+    switch (type_) {
+      case VariantType::Uint32:
+        return canConvertNumber<T>(content_.asUint32);
+
+      case VariantType::Int32:
+        return canConvertNumber<T>(content_.asInt32);
+
+#if ARDUINOJSON_USE_LONG_LONG
+      case VariantType::Uint64:
+        return canConvertNumber<T>(eightByteValue->asUint64);
+
+      case VariantType::Int64:
+        return canConvertNumber<T>(eightByteValue->asInt64);
+#endif
+
+      default:
+        return false;
+    }
+  }
+
+  bool isNull() const {
+    return type_ == VariantType::Null;
+  }
+
+  static bool isNull(const VariantData* var) {
+    if (!var)
+      return true;
+    return var->isNull();
+  }
+
+  bool isObject() const {
+    return type_ == VariantType::Object;
+  }
+
+  bool isString() const {
+    return type_ == VariantType::LinkedString ||
+           type_ == VariantType::OwnedString ||
+           type_ == VariantType::TinyString;
+  }
+
+  size_t nesting(const ResourceManager* resources) const {
+    auto collection = asCollection();
+    if (collection)
+      return collection->nesting(resources);
+    else
+      return 0;
+  }
+
+  static size_t nesting(const VariantData* var,
+                        const ResourceManager* resources) {
+    if (!var)
+      return 0;
+    return var->nesting(resources);
+  }
+
+  void removeElement(size_t index, ResourceManager* resources) {
+    ArrayData::removeElement(asArray(), index, resources);
+  }
+
+  static void removeElement(VariantData* var, size_t index,
+                            ResourceManager* resources) {
+    if (!var)
+      return;
+    var->removeElement(index, resources);
+  }
+
+  template <typename TAdaptedString>
+  void removeMember(TAdaptedString key, ResourceManager* resources) {
+    ObjectData::removeMember(asObject(), key, resources);
+  }
+
+  template <typename TAdaptedString>
+  static void removeMember(VariantData* var, TAdaptedString key,
+                           ResourceManager* resources) {
+    if (!var)
+      return;
+    var->removeMember(key, resources);
+  }
+
+  void reset() {  // TODO: remove
+    type_ = VariantType::Null;
+  }
+
+  void setBoolean(bool value) {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    type_ = VariantType::Boolean;
+    content_.asBoolean = value;
+  }
+
+  template <typename T>
+  enable_if_t<sizeof(T) == 4, bool> setFloat(T value, ResourceManager*) {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    type_ = VariantType::Float;
+    content_.asFloat = value;
+    return true;
+  }
+
+  template <typename T>
+  enable_if_t<sizeof(T) == 8, bool> setFloat(T value, ResourceManager*);
+
+  template <typename T>
+  enable_if_t<is_signed<T>::value, bool> setInteger(T value,
+                                                    ResourceManager* resources);
+
+  template <typename T>
+  enable_if_t<is_unsigned<T>::value, bool> setInteger(
+      T value, ResourceManager* resources);
+
+  void setRawString(StringNode* s) {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    ARDUINOJSON_ASSERT(s);
+    type_ = VariantType::RawString;
+    content_.asOwnedString = s;
+  }
+
+  template <typename T>
+  void setRawString(SerializedValue<T> value, ResourceManager* resources);
+
+  template <typename T>
+  static void setRawString(VariantData* var, SerializedValue<T> value,
+                           ResourceManager* resources) {
+    if (!var)
+      return;
+    var->clear(resources);
+    var->setRawString(value, resources);
+  }
+
+  template <typename TAdaptedString>
+  bool setString(TAdaptedString value, ResourceManager* resources);
+
+  template <typename TAdaptedString>
+  static void setString(VariantData* var, TAdaptedString value,
+                        ResourceManager* resources) {
+    if (!var)
+      return;
+    var->clear(resources);
+    var->setString(value, resources);
+  }
+
+  bool setLinkedString(const char* s, ResourceManager* resources);
+
   template <typename TAdaptedString>
   void setTinyString(const TAdaptedString& s) {
-    ARDUINOJSON_ASSERT(type == VariantType::Null);
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
     ARDUINOJSON_ASSERT(s.size() <= tinyStringMaxLength);
 
-    type = VariantType::TinyString;
+    type_ = VariantType::TinyString;
 
     auto n = uint8_t(s.size());
     for (uint8_t i = 0; i < n; i++) {
       char c = s[i];
       ARDUINOJSON_ASSERT(c != 0);  // no NUL in tiny string
-      content.asTinyString[i] = c;
+      content_.asTinyString[i] = c;
     }
 
-    content.asTinyString[n] = 0;
+    content_.asTinyString[n] = 0;
   }
 
-  void setLongString(StringNode* s) {
-    ARDUINOJSON_ASSERT(type == VariantType::Null);
+  void setOwnedString(StringNode* s) {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
     ARDUINOJSON_ASSERT(s);
-    type = VariantType::LongString;
-    content.asStringNode = s;
+    type_ = VariantType::OwnedString;
+    content_.asOwnedString = s;
   }
 
-  CollectionData* toArray() {
-    ARDUINOJSON_ASSERT(type == VariantType::Null);
-    type = VariantType::Array;
-    return new (&content.asCollection) CollectionData();
+  size_t size(const ResourceManager* resources) const {
+    if (isObject())
+      return content_.asObject.size(resources);
+
+    if (isArray())
+      return content_.asArray.size(resources);
+
+    return 0;
   }
 
-  CollectionData* toObject() {
-    ARDUINOJSON_ASSERT(type == VariantType::Null);
-    type = VariantType::Object;
-    return new (&content.asCollection) CollectionData();
+  static size_t size(const VariantData* var, const ResourceManager* resources) {
+    return var != 0 ? var->size(resources) : 0;
+  }
+
+  ArrayData& toArray() {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    type_ = VariantType::Array;
+    new (&content_.asArray) ArrayData();
+    return content_.asArray;
+  }
+
+  static VariantData* toArray(VariantData* var, ResourceManager* resources) {
+    if (!var)
+      return 0;
+    var->clear(resources);
+    var->toArray();
+    return var;
+  }
+
+  ObjectData& toObject() {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    type_ = VariantType::Object;
+    new (&content_.asObject) ObjectData();
+    return content_.asObject;
+  }
+
+  static VariantData* toObject(VariantData* var, ResourceManager* resources) {
+    if (!var)
+      return 0;
+    var->clear(resources);
+    var->toObject();
+    return var;
+  }
+
+  VariantType type() const {
+    return type_;
+  }
+
+  // Release the resources used by this variant and set it to null.
+  void clear(ResourceManager* resources);
+
+  static void clear(VariantData* var, ResourceManager* resources) {
+    if (!var)
+      return;
+    var->clear(resources);
   }
 };
 

src/ArduinoJson/Variant/VariantDataVisitor.hpp

@@ -4,8 +4,10 @@
 
 #pragma once
 
+#include <ArduinoJson/Array/ArrayData.hpp>
 #include <ArduinoJson/Numbers/JsonFloat.hpp>
 #include <ArduinoJson/Numbers/JsonInteger.hpp>
+#include <ArduinoJson/Object/ObjectData.hpp>
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
@@ -17,14 +19,6 @@ struct VariantDataVisitor {
   TResult visit(const T&) {
     return TResult();
   }
-
-  TResult visitArray(VariantData*) {
-    return TResult();
-  }
-
-  TResult visitObject(VariantData*) {
-    return TResult();
-  }
 };
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Variant/VariantImpl.hpp

@@ -4,638 +4,161 @@
 
 #pragma once
 
-#include <ArduinoJson/Collection/CollectionIterator.hpp>
 #include <ArduinoJson/Memory/ResourceManager.hpp>
-#include <ArduinoJson/Misc/SerializedValue.hpp>
-#include <ArduinoJson/Numbers/convertNumber.hpp>
-#include <ArduinoJson/Strings/JsonString.hpp>
-#include <ArduinoJson/Strings/StringAdapters.hpp>
 #include <ArduinoJson/Variant/VariantData.hpp>
 
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
-// HACK: large functions are implemented in static function to give opportunity
-// to the compiler to optimize the `this` pointer away.
-class VariantImpl {
- public:
-  using iterator = CollectionIterator;
-
-  VariantImpl() : data_(nullptr), resources_(nullptr) {}
-
-  VariantImpl(VariantData* data, ResourceManager* resources)
-      : data_(data), resources_(resources) {}
-
-  VariantData* data() const {
-    return data_;
-  }
-
-  ResourceManager* resources() const {
-    return resources_;
-  }
-
-  template <typename TVisitor>
-  typename TVisitor::result_type accept(TVisitor& visit) {
-    return accept(visit, data_, resources_);
-  }
-
-  template <typename TVisitor>
-  static typename TVisitor::result_type accept(TVisitor& visit,
-                                               VariantData* data,
-                                               ResourceManager* resources) {
-    if (!data)
-      return visit.visit(nullptr);
-
-#if ARDUINOJSON_USE_8_BYTE_POOL
-    auto eightByteValue = getEightByte(data, resources);
-#endif
-    switch (data->type) {
-      case VariantType::Float:
-        return visit.visit(data->content.asFloat);
-
-#if ARDUINOJSON_USE_DOUBLE
-      case VariantType::Double:
-        return visit.visit(eightByteValue->asDouble);
-#endif
-
-      case VariantType::Array:
-        return visit.visitArray(data);
-
-      case VariantType::Object:
-        return visit.visitObject(data);
-
-      case VariantType::TinyString:
-        return visit.visit(JsonString(data->content.asTinyString));
-
-      case VariantType::LongString:
-        return visit.visit(JsonString(data->content.asStringNode->data,
-                                      data->content.asStringNode->length));
-
-      case VariantType::RawString:
-        return visit.visit(RawString(data->content.asStringNode->data,
-                                     data->content.asStringNode->length));
-
-      case VariantType::Int32:
-        return visit.visit(static_cast<JsonInteger>(data->content.asInt32));
-
-      case VariantType::Uint32:
-        return visit.visit(static_cast<JsonUInt>(data->content.asUint32));
-
-#if ARDUINOJSON_USE_LONG_LONG
-      case VariantType::Int64:
-        return visit.visit(eightByteValue->asInt64);
-
-      case VariantType::Uint64:
-        return visit.visit(eightByteValue->asUint64);
-#endif
-
-      case VariantType::Boolean:
-        return visit.visit(data->content.asBoolean != 0);
-
-      default:
-        return visit.visit(nullptr);
-    }
-  }
-
-  VariantData* addNewElement() {
-    if (!isArray())
-      return nullptr;
-    return addNewElement(data_, resources_);
-  }
-
-  static VariantData* addNewElement(VariantData*, ResourceManager*);
-
-  static void addElement(Slot<VariantData> slot, VariantData*,
-                         ResourceManager*);
-
-  template <typename TAdaptedString>
-  VariantData* addMember(TAdaptedString key) {
-    if (!isObject())
-      return nullptr;
-    return addMember(key, data_, resources_);
-  }
-
-  template <typename TAdaptedString>
-  static VariantData* addMember(TAdaptedString key, VariantData*,
-                                ResourceManager*);
-
-  VariantData* addPair(VariantData** value) {
-    if (isNull())
-      return nullptr;
-    return addPair(value, data_, resources_);
-  }
-
-  static VariantData* addPair(VariantData** value, VariantData*,
-                              ResourceManager*);
-
-  bool asBoolean() const {
-    return asBoolean(data_, resources_);
-  }
-
-  static bool asBoolean(VariantData* data, ResourceManager* resources) {
-    if (!data)
-      return false;
-
-#if ARDUINOJSON_USE_8_BYTE_POOL
-    auto eightByteValue = getEightByte(data, resources);
-#endif
-    switch (data->type) {
-      case VariantType::Boolean:
-        return data->content.asBoolean;
-      case VariantType::Uint32:
-      case VariantType::Int32:
-        return data->content.asUint32 != 0;
-      case VariantType::Float:
-        return data->content.asFloat != 0;
-#if ARDUINOJSON_USE_DOUBLE
-      case VariantType::Double:
-        return eightByteValue->asDouble != 0;
-#endif
-      case VariantType::Null:
-        return false;
-#if ARDUINOJSON_USE_LONG_LONG
-      case VariantType::Uint64:
-      case VariantType::Int64:
-        return eightByteValue->asUint64 != 0;
-#endif
-      default:
-        return true;
-    }
-  }
-
-  template <typename T>
-  T asFloat() const {
-    return asFloat<T>(data_, resources_);
-  }
-
-  template <typename T>
-  static T asFloat(VariantData* data, ResourceManager* resources) {
-    if (!data)
-      return 0.0;
-
-    static_assert(is_floating_point<T>::value, "T must be a floating point");
-#if ARDUINOJSON_USE_8_BYTE_POOL
-    auto eightByteValue = getEightByte(data, resources);
-#endif
-    const char* str = nullptr;
-    switch (data->type) {
-      case VariantType::Boolean:
-        return static_cast<T>(data->content.asBoolean);
-      case VariantType::Uint32:
-        return static_cast<T>(data->content.asUint32);
-      case VariantType::Int32:
-        return static_cast<T>(data->content.asInt32);
-#if ARDUINOJSON_USE_LONG_LONG
-      case VariantType::Uint64:
-        return static_cast<T>(eightByteValue->asUint64);
-      case VariantType::Int64:
-        return static_cast<T>(eightByteValue->asInt64);
-#endif
-      case VariantType::TinyString:
-        str = data->content.asTinyString;
-        break;
-      case VariantType::LongString:
-        str = data->content.asStringNode->data;
-        break;
-      case VariantType::Float:
-        return static_cast<T>(data->content.asFloat);
-#if ARDUINOJSON_USE_DOUBLE
-      case VariantType::Double:
-        return static_cast<T>(eightByteValue->asDouble);
-#endif
-      default:
-        return 0.0;
-    }
-
-    ARDUINOJSON_ASSERT(str != nullptr);
-    return parseNumber<T>(str);
-  }
-
-  template <typename T>
-  T asIntegral() const {
-    return asIntegral<T>(data_, resources_);
-  }
-
-  template <typename T>
-  static T asIntegral(VariantData* data, ResourceManager* resources) {
-    if (!data)
-      return 0;
-
-    static_assert(is_integral<T>::value, "T must be an integral type");
-#if ARDUINOJSON_USE_8_BYTE_POOL
-    auto eightByteValue = getEightByte(data, resources);
-#endif
-    const char* str = nullptr;
-    switch (data->type) {
-      case VariantType::Boolean:
-        return data->content.asBoolean;
-      case VariantType::Uint32:
-        return convertNumber<T>(data->content.asUint32);
-      case VariantType::Int32:
-        return convertNumber<T>(data->content.asInt32);
-#if ARDUINOJSON_USE_LONG_LONG
-      case VariantType::Uint64:
-        return convertNumber<T>(eightByteValue->asUint64);
-      case VariantType::Int64:
-        return convertNumber<T>(eightByteValue->asInt64);
-#endif
-      case VariantType::TinyString:
-        str = data->content.asTinyString;
-        break;
-      case VariantType::LongString:
-        str = data->content.asStringNode->data;
-        break;
-      case VariantType::Float:
-        return convertNumber<T>(data->content.asFloat);
-#if ARDUINOJSON_USE_DOUBLE
-      case VariantType::Double:
-        return convertNumber<T>(eightByteValue->asDouble);
-#endif
-      default:
-        return 0;
-    }
-
-    ARDUINOJSON_ASSERT(str != nullptr);
-    return parseNumber<T>(str);
-  }
-
-  iterator at(size_t index) const;
-
-  iterator createIterator() const {
-    if (!isCollection())
-      return iterator();
-    return createIterator(data_, resources_);
-  }
-
-  static iterator createIterator(VariantData*, ResourceManager*);
-
-#if ARDUINOJSON_USE_8_BYTE_POOL
-  static const EightByteValue* getEightByte(VariantData* data,
-                                            ResourceManager* resources) {
-    ARDUINOJSON_ASSERT(data != nullptr);
-    ARDUINOJSON_ASSERT(resources != nullptr);
-    return data->type & VariantTypeBits::EightByteBit
-               ? resources->getEightByte(data->content.asSlotId)
-               : 0;
-  }
-#endif
-
-  VariantData* getOrAddElement(size_t index);
-
-  VariantData* getElement(size_t index) const;
-
-  template <typename TAdaptedString>
-  VariantData* getMember(TAdaptedString key) const {
-    if (!isObject())
-      return nullptr;
-    return getMember(key, data_, resources_);
-  }
-
-  template <typename TAdaptedString>
-  static VariantData* getMember(TAdaptedString key, VariantData*,
-                                ResourceManager*);
-
-  template <typename TAdaptedString>
-  VariantData* getOrAddMember(TAdaptedString key) {
-    if (!isObject())
-      return nullptr;
-    return getOrAddMember(key, data_, resources_);
-  }
-
-  template <typename TAdaptedString>
-  static VariantData* getOrAddMember(TAdaptedString key, VariantData*,
-                                     ResourceManager*);
-
-  bool isArray() const {
-    return type() == VariantType::Array;
-  }
-
-  bool isCollection() const {
-    return type() & VariantTypeBits::CollectionMask;
-  }
-
-  template <typename T>
-  bool isInteger() const {
-    return isInteger<T>(data_, resources_);
-  }
-
-  template <typename T>
-  static bool isInteger(VariantData* data, ResourceManager* resources) {
-    if (!data)
-      return false;
-
-#if ARDUINOJSON_USE_LONG_LONG
-    auto eightByteValue = getEightByte(data, resources);
-#else
-    (void)resources;
-#endif
-    switch (data->type) {
-      case VariantType::Uint32:
-        return canConvertNumber<T>(data->content.asUint32);
-
-      case VariantType::Int32:
-        return canConvertNumber<T>(data->content.asInt32);
-
-#if ARDUINOJSON_USE_LONG_LONG
-      case VariantType::Uint64:
-        return canConvertNumber<T>(eightByteValue->asUint64);
-
-      case VariantType::Int64:
-        return canConvertNumber<T>(eightByteValue->asInt64);
-#endif
-
-      default:
-        return false;
-    }
-  }
-
-  bool isNull() const {
-    return type() == VariantType::Null;
-  }
-
-  bool isObject() const {
-    return type() == VariantType::Object;
-  }
-
-  size_t nesting() const;
-
-  void removeElement(size_t index);
-
-  void removeElement(CollectionIterator it) {
-    removeOne(it);
-  }
-
-  template <typename TAdaptedString>
-  void removeMember(TAdaptedString key) {
-    removePair(findKey(key));
-  }
-
-  void removeMember(CollectionIterator it) {
-    removePair(it);
-  }
-
-  bool setBoolean(bool value) {
-    if (!data_)
-      return false;
-    clear(data_, resources_);
-    data_->setBoolean(value);
-    return true;
-  }
-
-  template <typename T>
-  bool setFloat(T value) {
-    if (!data_)
-      return false;
-    clear(data_, resources_);
-    return setFloat(value, data_, resources_);
-  }
-
-  template <typename T>
-  static enable_if_t<sizeof(T) == 4, bool> setFloat(T value, VariantData* data,
-                                                    ResourceManager*) {
-    ARDUINOJSON_ASSERT(data != nullptr);
-    ARDUINOJSON_ASSERT(data->type == VariantType::Null);
-    data->type = VariantType::Float;
-    data->content.asFloat = value;
-    return true;
-  }
-
-  template <typename T>
-  static enable_if_t<sizeof(T) == 8, bool> setFloat(
-      T value, VariantData* data, ResourceManager* resources) {
-    ARDUINOJSON_ASSERT(data != nullptr);
-    ARDUINOJSON_ASSERT(data->type == VariantType::Null);
-    ARDUINOJSON_ASSERT(resources != nullptr);
-
-    float valueAsFloat = static_cast<float>(value);
-
-#if ARDUINOJSON_USE_DOUBLE
-    if (value == valueAsFloat) {
-      data->type = VariantType::Float;
-      data->content.asFloat = valueAsFloat;
-    } else {
-      auto slot = resources->allocEightByte();
-      if (!slot)
-        return false;
-      data->type = VariantType::Double;
-      data->content.asSlotId = slot.id();
-      slot->asDouble = value;
-    }
-#else
-    data->type = VariantType::Float;
-    data->content.asFloat = valueAsFloat;
-#endif
-    return true;
-  }
-
-  template <typename T>
-  bool setInteger(T value) {
-    if (!data_)
-      return false;
-    clear(data_, resources_);
-    return setInteger(value, data_, resources_);
-  }
-
-  template <typename T>
-  static enable_if_t<is_signed<T>::value, bool> setInteger(
-      T value, VariantData* data, ResourceManager* resources) {
-    ARDUINOJSON_ASSERT(data != nullptr);
-    ARDUINOJSON_ASSERT(data->type == VariantType::Null);
-    ARDUINOJSON_ASSERT(resources != nullptr);
-
-    if (canConvertNumber<int32_t>(value)) {
-      data->type = VariantType::Int32;
-      data->content.asInt32 = static_cast<int32_t>(value);
-    }
-#if ARDUINOJSON_USE_LONG_LONG
-    else {
-      auto slot = resources->allocEightByte();
-      if (!slot)
-        return false;
-      data->type = VariantType::Int64;
-      data->content.asSlotId = slot.id();
-      slot->asInt64 = value;
-    }
-#else
-    (void)resources;
-#endif
-    return true;
-  }
-
-  template <typename T>
-  static enable_if_t<is_unsigned<T>::value, bool> setInteger(
-      T value, VariantData* data, ResourceManager* resources) {
-    ARDUINOJSON_ASSERT(data != nullptr);
-    ARDUINOJSON_ASSERT(data->type == VariantType::Null);
-    ARDUINOJSON_ASSERT(resources != nullptr);
-
-    if (canConvertNumber<uint32_t>(value)) {
-      data->type = VariantType::Uint32;
-      data->content.asUint32 = static_cast<uint32_t>(value);
-    }
-#if ARDUINOJSON_USE_LONG_LONG
-    else {
-      auto slot = resources->allocEightByte();
-      if (!slot)
-        return false;
-      data->type = VariantType::Uint64;
-      data->content.asSlotId = slot.id();
-      slot->asUint64 = value;
-    }
-#else
-    (void)resources;
-#endif
-    return true;
-  }
-
-  template <typename TAdaptedString>
-  bool setRawString(TAdaptedString value) {
-    if (!data_)
-      return false;
-    clear(data_, resources_);
-    auto dup = resources_->saveString(adaptString(value.data(), value.size()));
-    if (!dup)
-      return false;
-    data_->setRawString(dup);
-    return true;
-  }
-
-  template <typename TAdaptedString>
-  bool setString(TAdaptedString value) {
-    if (!data_)
-      return false;
-    clear(data_, resources_);
-    return setString(value, data_, resources_);
-  }
-
-  template <typename TAdaptedString>
-  static bool setString(TAdaptedString value, VariantData* data,
-                        ResourceManager* resources) {
-    ARDUINOJSON_ASSERT(data != nullptr);
-    ARDUINOJSON_ASSERT(data->type == VariantType::Null);
-    ARDUINOJSON_ASSERT(resources != nullptr);
-
-    if (value.isNull())
-      return true;  // TODO: should this be moved up to the member function?
-
-    if (isTinyString(value, value.size())) {
-      data->setTinyString(value);
-      return true;
-    }
-
-    auto dup = resources->saveString(value);
-    if (dup) {
-      data->setLongString(dup);
-      return true;
-    }
-
+template <typename T>
+inline void VariantData::setRawString(SerializedValue<T> value,
+                                      ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  auto dup = resources->saveString(adaptString(value.data(), value.size()));
+  if (dup)
+    setRawString(dup);
+}
+
+inline bool VariantData::setLinkedString(const char* s,
+                                         ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  ARDUINOJSON_ASSERT(s);
+
+  auto slotId = resources->saveStaticString(s);
+  if (slotId == NULL_SLOT)
     return false;
-  }
 
-  size_t size() const {
-    if (!isCollection())
-      return 0;
+  type_ = VariantType::LinkedString;
+  content_.asSlotId = slotId;
+  return true;
+}
 
-    return size(data_, resources_);
-  }
+template <typename TAdaptedString>
+inline bool VariantData::setString(TAdaptedString value,
+                                   ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
 
-  static size_t size(VariantData* data, ResourceManager* resources) {
-    ARDUINOJSON_ASSERT(data != nullptr);
-    ARDUINOJSON_ASSERT(data->isCollection());
-    ARDUINOJSON_ASSERT(resources != nullptr);
+  if (value.isNull())
+    return false;
 
-    size_t n = 0;
-    for (auto it = createIterator(data, resources); !it.done();
-         it.move(resources))
-      n++;
+  if (value.isStatic())
+    return setLinkedString(value.data(), resources);
 
-    if (data->type == VariantType::Object) {
-      ARDUINOJSON_ASSERT((n % 2) == 0);
-      n /= 2;
-    }
-
-    return n;
-  }
-
-  bool toArray() {
-    if (!data_)
-      return false;
-    clear(data_, resources_);
-    data_->toArray();
+  if (isTinyString(value, value.size())) {
+    setTinyString(value);
     return true;
   }
 
-  bool toObject() {
-    if (!data_)
-      return false;
-    clear(data_, resources_);
-    data_->toObject();
+  auto dup = resources->saveString(value);
+  if (dup) {
+    setOwnedString(dup);
     return true;
   }
 
-  VariantType type() const {
-    return data_ ? data_->type : VariantType::Null;
-  }
+  return false;
+}
 
-  // Release the resources used by this variant and set it to null.
-  bool clear() {
-    if (!data_)
-      return false;
-    clear(data_, resources_);
-    return true;
-  }
-
-  static void clear(VariantData* data, ResourceManager* resources) {
-    ARDUINOJSON_ASSERT(data != nullptr);
-    ARDUINOJSON_ASSERT(resources != nullptr);
-
-    if (data->type & VariantTypeBits::OwnedStringBit)
-      resources->dereferenceString(data->content.asStringNode->data);
+inline void VariantData::clear(ResourceManager* resources) {
+  if (type_ & VariantTypeBits::OwnedStringBit)
+    resources->dereferenceString(content_.asOwnedString->data);
 
 #if ARDUINOJSON_USE_8_BYTE_POOL
-    if (data->type & VariantTypeBits::EightByteBit)
-      resources->freeEightByte(data->content.asSlotId);
+  if (type_ & VariantTypeBits::EightByteBit)
+    resources->freeEightByte(content_.asSlotId);
 #endif
 
-    if (data->type & VariantTypeBits::CollectionMask)
-      empty(data, resources);
+  auto collection = asCollection();
+  if (collection)
+    collection->clear(resources);
 
-    data->type = VariantType::Null;
+  type_ = VariantType::Null;
+}
+
+#if ARDUINOJSON_USE_8_BYTE_POOL
+inline const EightByteValue* VariantData::getEightByte(
+    const ResourceManager* resources) const {
+  return type_ & VariantTypeBits::EightByteBit
+             ? resources->getEightByte(content_.asSlotId)
+             : 0;
+}
+#endif
+
+inline const char* VariantData::asLinkedString(
+    const ResourceManager* resources) const {
+  ARDUINOJSON_ASSERT(type_ == VariantType::LinkedString);
+  return resources->getStaticString(content_.asSlotId);
+}
+
+template <typename T>
+enable_if_t<sizeof(T) == 8, bool> VariantData::setFloat(
+    T value, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  (void)resources;                                 // silence warning
+
+  float valueAsFloat = static_cast<float>(value);
+
+#if ARDUINOJSON_USE_DOUBLE
+  if (value == valueAsFloat) {
+    type_ = VariantType::Float;
+    content_.asFloat = valueAsFloat;
+  } else {
+    auto slot = resources->allocEightByte();
+    if (!slot)
+      return false;
+    type_ = VariantType::Double;
+    content_.asSlotId = slot.id();
+    slot->asDouble = value;
   }
+#else
+  type_ = VariantType::Float;
+  content_.asFloat = valueAsFloat;
+#endif
+  return true;
+}
 
-  void empty() {
-    if (!isCollection())
-      return;
-    empty(data_, resources_);
+template <typename T>
+enable_if_t<is_signed<T>::value, bool> VariantData::setInteger(
+    T value, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  (void)resources;                                 // silence warning
+
+  if (canConvertNumber<int32_t>(value)) {
+    type_ = VariantType::Int32;
+    content_.asInt32 = static_cast<int32_t>(value);
   }
-
-  static void empty(VariantData*, ResourceManager*);
-
-  static void freeVariant(Slot<VariantData> slot, ResourceManager* resources) {
-    clear(slot.ptr(), resources);
-    resources->freeVariant(slot);
+#if ARDUINOJSON_USE_LONG_LONG
+  else {
+    auto slot = resources->allocEightByte();
+    if (!slot)
+      return false;
+    type_ = VariantType::Int64;
+    content_.asSlotId = slot.id();
+    slot->asInt64 = value;
   }
+#endif
+  return true;
+}
 
- private:
-  VariantData* data_;
-  ResourceManager* resources_;
+template <typename T>
+enable_if_t<is_unsigned<T>::value, bool> VariantData::setInteger(
+    T value, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+  (void)resources;                                 // silence warning
 
-  template <typename TAdaptedString>
-  iterator findKey(TAdaptedString key) const {
-    if (!isObject())
-      return iterator();
-    return findKey(key, data_, resources_);
+  if (canConvertNumber<uint32_t>(value)) {
+    type_ = VariantType::Uint32;
+    content_.asUint32 = static_cast<uint32_t>(value);
   }
-
-  template <typename TAdaptedString>
-  static iterator findKey(TAdaptedString key, VariantData*, ResourceManager*);
-
-  static void appendPair(Slot<VariantData> key, Slot<VariantData> value,
-                         VariantData*, ResourceManager*);
-
-  void removeOne(iterator it);
-  void removePair(iterator it);
-
-  Slot<VariantData> getPreviousSlot(VariantData*) const;
-};
+#if ARDUINOJSON_USE_LONG_LONG
+  else {
+    auto slot = resources->allocEightByte();
+    if (!slot)
+      return false;
+    type_ = VariantType::Uint64;
+    content_.asSlotId = slot.id();
+    slot->asUint64 = value;
+  }
+#endif
+  return true;
+}
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Variant/VariantRefBase.hpp

@@ -8,6 +8,7 @@
 #include <ArduinoJson/Variant/Converter.hpp>
 #include <ArduinoJson/Variant/JsonVariantConst.hpp>
 #include <ArduinoJson/Variant/VariantOperators.hpp>
+#include <ArduinoJson/Variant/VariantTo.hpp>
 
 ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
 class JsonVariant;
@@ -28,13 +29,13 @@ class VariantRefBase : public VariantTag {
   // Sets the value to null.
   // https://arduinojson.org/v7/api/jsonvariant/clear/
   void clear() const {
-    getOrCreateVariantImpl().clear();
+    VariantData::clear(getOrCreateData(), getResourceManager());
   }
 
   // Returns true if the value is null or the reference is unbound.
   // https://arduinojson.org/v7/api/jsonvariant/isnull/
   bool isNull() const {
-    return getVariantImpl().isNull();
+    return VariantData::isNull(getData());
   }
 
   // Returns true if the reference is unbound.
@@ -76,13 +77,15 @@ class VariantRefBase : public VariantTag {
   // https://arduinojson.org/v7/api/jsonvariant/set/
   template <typename T>
   bool set(const T& value) const {
-    using TypeForConverter = remove_cv_t<remove_reference_t<T>>;
+    using TypeForConverter = conditional_t<IsStringLiteral<T>::value, T,
+                                           remove_cv_t<remove_reference_t<T>>>;
     return doSet<Converter<TypeForConverter>>(value);
   }
 
   // Copies the specified value.
   // https://arduinojson.org/v7/api/jsonvariant/set/
-  template <typename T>
+  template <typename T,
+            detail::enable_if_t<!detail::is_const<T>::value, int> = 0>
   bool set(T* value) const {
     return doSet<Converter<T*>>(value);
   }
@@ -90,13 +93,13 @@ class VariantRefBase : public VariantTag {
   // Returns the size of the array or object.
   // https://arduinojson.org/v7/api/jsonvariant/size/
   size_t size() const {
-    return getVariantImpl().size();
+    return VariantData::size(getData(), getResourceManager());
   }
 
   // Returns the depth (nesting level) of the value.
   // https://arduinojson.org/v7/api/jsonvariant/nesting/
   size_t nesting() const {
-    return getVariantImpl().nesting();
+    return VariantData::nesting(getData(), getResourceManager());
   }
 
   // Appends a new (empty) element to the array.
@@ -117,34 +120,38 @@ class VariantRefBase : public VariantTag {
   // https://arduinojson.org/v7/api/jsonvariant/add/
   template <typename T>
   bool add(const T& value) const {
-    return getOrCreateArray().add(value);
+    return detail::VariantData::addValue(getOrCreateData(), value,
+                                         getResourceManager());
   }
 
   // Appends a value to the array.
   // https://arduinojson.org/v7/api/jsonvariant/add/
-  template <typename T>
+  template <typename T, enable_if_t<!is_const<T>::value, int> = 0>
   bool add(T* value) const {
-    return getOrCreateArray().add(value);
+    return detail::VariantData::addValue(getOrCreateData(), value,
+                                         getResourceManager());
   }
 
   // Removes an element of the array.
   // https://arduinojson.org/v7/api/jsonvariant/remove/
   void remove(size_t index) const {
-    getVariantImpl().removeElement(index);
+    VariantData::removeElement(getData(), index, getResourceManager());
   }
 
   // Removes a member of the object.
   // https://arduinojson.org/v7/api/jsonvariant/remove/
   template <typename TChar, enable_if_t<IsString<TChar*>::value, int> = 0>
   void remove(TChar* key) const {
-    getVariantImpl().removeMember(adaptString(key));
+    VariantData::removeMember(getData(), adaptString(key),
+                              getResourceManager());
   }
 
   // Removes a member of the object.
   // https://arduinojson.org/v7/api/jsonvariant/remove/
   template <typename TString, enable_if_t<IsString<TString>::value, int> = 0>
   void remove(const TString& key) const {
-    getVariantImpl().removeMember(adaptString(key));
+    VariantData::removeMember(getData(), adaptString(key),
+                              getResourceManager());
   }
 
   // Removes a member of the object or an element of the array.
@@ -187,7 +194,9 @@ class VariantRefBase : public VariantTag {
 
   // Gets or sets an object member.
   // https://arduinojson.org/v7/api/jsonvariant/subscript/
-  template <typename TChar, enable_if_t<IsString<TChar*>::value, int> = 0>
+  template <
+      typename TChar,
+      enable_if_t<IsString<TChar*>::value && !is_const<TChar>::value, int> = 0>
   FORCE_INLINE MemberProxy<TDerived, AdaptedString<TChar*>> operator[](
       TChar* key) const;
 
@@ -266,16 +275,6 @@ class VariantRefBase : public VariantTag {
     return VariantAttorney::getOrCreateData(derived());
   }
 
-  VariantImpl getVariantImpl() const {
-    return VariantImpl(getData(), getResourceManager());
-  }
-
-  VariantImpl getOrCreateVariantImpl() const {
-    return VariantImpl(getOrCreateData(), getResourceManager());
-  }
-
-  JsonArray getOrCreateArray() const;
-
   FORCE_INLINE ArduinoJson::JsonVariant getVariant() const;
 
   FORCE_INLINE ArduinoJson::JsonVariantConst getVariantConst() const {