Remove `JSON_ARRAY_SIZE()`, `JSON_OBJECT_SIZE()`, and `JSON_STRING_SIZE()`

CHANGELOG.md

@@ -8,3 +8,4 @@ HEAD
 * Remove `StaticJsonDocument`
 * Add abstract `Allocator` class
 * Merge `DynamicJsonDocument` with `JsonDocument`
+* Remove `JSON_ARRAY_SIZE()`, `JSON_OBJECT_SIZE()`, and `JSON_STRING_SIZE()`

examples/JsonHttpClient/JsonHttpClient.ino

@@ -78,8 +78,7 @@ void setup() {
 
   // Allocate the JSON document
   // Use https://arduinojson.org/v6/assistant to compute the capacity.
-  const size_t capacity = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2) + 60;
-  JsonDocument doc(capacity);
+  JsonDocument doc(256);
 
   // Parse JSON object
   DeserializationError error = deserializeJson(doc, client);

extras/tests/Cpp17/string_view.cpp

@@ -7,6 +7,8 @@
 #  error ARDUINOJSON_ENABLE_STRING_VIEW must be set to 1
 #endif
 
+using ArduinoJson::detail::sizeofArray;
+
 TEST_CASE("string_view") {
   JsonDocument doc(256);
   JsonVariant variant = doc.to<JsonVariant>();
@@ -53,16 +55,16 @@ TEST_CASE("string_view") {
 
   SECTION("String deduplication") {
     doc.add(std::string_view("example one", 7));
-    REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1) + 8);
+    REQUIRE(doc.memoryUsage() == sizeofArray(1) + 8);
 
     doc.add(std::string_view("example two", 7));
-    REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 8);
+    REQUIRE(doc.memoryUsage() == sizeofArray(2) + 8);
 
     doc.add(std::string_view("example\0tree", 12));
-    REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(3) + 21);
+    REQUIRE(doc.memoryUsage() == sizeofArray(3) + 21);
 
     doc.add(std::string_view("example\0tree and a half", 12));
-    REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(4) + 21);
+    REQUIRE(doc.memoryUsage() == sizeofArray(4) + 21);
   }
 
   SECTION("as<std::string_view>()") {

extras/tests/JsonArray/add.cpp

@@ -5,6 +5,9 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofString;
+
 TEST_CASE("JsonArray::add()") {
   JsonDocument doc(4096);
   JsonArray array = doc.to<JsonArray>();
@@ -96,43 +99,43 @@ TEST_CASE("JsonArray::add()") {
 
   SECTION("should not duplicate const char*") {
     array.add("world");
-    const size_t expectedSize = JSON_ARRAY_SIZE(1);
+    const size_t expectedSize = sizeofArray(1);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should duplicate char*") {
     array.add(const_cast<char*>("world"));
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(5);
+    const size_t expectedSize = sizeofArray(1) + sizeofString(5);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should duplicate std::string") {
     array.add(std::string("world"));
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(5);
+    const size_t expectedSize = sizeofArray(1) + sizeofString(5);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should not duplicate serialized(const char*)") {
     array.add(serialized("{}"));
-    const size_t expectedSize = JSON_ARRAY_SIZE(1);
+    const size_t expectedSize = sizeofArray(1);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should duplicate serialized(char*)") {
     array.add(serialized(const_cast<char*>("{}")));
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(2);
+    const size_t expectedSize = sizeofArray(1) + sizeofString(2);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should duplicate serialized(std::string)") {
     array.add(serialized(std::string("{}")));
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(2);
+    const size_t expectedSize = sizeofArray(1) + sizeofString(2);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should duplicate serialized(std::string)") {
     array.add(serialized(std::string("\0XX", 3)));
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(3);
+    const size_t expectedSize = sizeofArray(1) + sizeofString(3);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 }

extras/tests/JsonArray/copyArray.cpp

@@ -5,6 +5,8 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+
 TEST_CASE("copyArray()") {
   SECTION("int[] -> JsonArray") {
     JsonDocument doc(4096);
@@ -107,7 +109,7 @@ TEST_CASE("copyArray()") {
   }
 
   SECTION("int[] -> JsonArray, but not enough memory") {
-    const size_t SIZE = JSON_ARRAY_SIZE(2);
+    const size_t SIZE = sizeofArray(2);
     JsonDocument doc(SIZE);
     JsonArray array = doc.to<JsonArray>();
     char json[32];
@@ -158,8 +160,7 @@ TEST_CASE("copyArray()") {
   }
 
   SECTION("int[][] -> JsonArray, but not enough memory") {
-    const size_t SIZE =
-        JSON_ARRAY_SIZE(2) + JSON_ARRAY_SIZE(3) + JSON_ARRAY_SIZE(2);
+    const size_t SIZE = sizeofArray(2) + sizeofArray(3) + sizeofArray(2);
     JsonDocument doc(SIZE);
     JsonArray array = doc.to<JsonArray>();
     char json[32] = "";

extras/tests/JsonArray/iterator.cpp

@@ -5,9 +5,11 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+
 template <typename TArray>
 static void run_iterator_test() {
-  JsonDocument doc(JSON_ARRAY_SIZE(2));
+  JsonDocument doc(sizeofArray(2));
   JsonArray tmp = doc.to<JsonArray>();
   tmp.add(12);
   tmp.add(34);

extras/tests/JsonArray/memoryUsage.cpp

@@ -5,6 +5,9 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
+
 TEST_CASE("JsonArray::memoryUsage()") {
   JsonDocument doc(4096);
   JsonArray arr = doc.to<JsonArray>();
@@ -14,29 +17,29 @@ TEST_CASE("JsonArray::memoryUsage()") {
     REQUIRE(unitialized.memoryUsage() == 0);
   }
 
-  SECTION("JSON_ARRAY_SIZE(0) if empty") {
-    REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(0));
+  SECTION("sizeofArray(0) if empty") {
+    REQUIRE(arr.memoryUsage() == sizeofArray(0));
   }
 
-  SECTION("JSON_ARRAY_SIZE(1) after add") {
+  SECTION("sizeofArray(1) after add") {
     arr.add("hello");
-    REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(1));
+    REQUIRE(arr.memoryUsage() == sizeofArray(1));
   }
 
   SECTION("includes the size of the string") {
     arr.add(std::string("hello"));
-    REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(1) + 6);
+    REQUIRE(arr.memoryUsage() == sizeofArray(1) + 6);
   }
 
   SECTION("includes the size of the nested array") {
     JsonArray nested = arr.createNestedArray();
     nested.add(42);
-    REQUIRE(arr.memoryUsage() == 2 * JSON_ARRAY_SIZE(1));
+    REQUIRE(arr.memoryUsage() == 2 * sizeofArray(1));
   }
 
   SECTION("includes the size of the nested arrect") {
     JsonObject nested = arr.createNestedObject();
     nested["hello"] = "world";
-    REQUIRE(arr.memoryUsage() == JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(1));
+    REQUIRE(arr.memoryUsage() == sizeofObject(1) + sizeofArray(1));
   }
 }

extras/tests/JsonArray/subscript.cpp

@@ -6,6 +6,9 @@
 #include <stdint.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofString;
+
 TEST_CASE("JsonArray::operator[]") {
   JsonDocument doc(4096);
   JsonArray array = doc.to<JsonArray>();
@@ -112,19 +115,19 @@ TEST_CASE("JsonArray::operator[]") {
 
   SECTION("should not duplicate const char*") {
     array[0] = "world";
-    const size_t expectedSize = JSON_ARRAY_SIZE(1);
+    const size_t expectedSize = sizeofArray(1);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should duplicate char*") {
     array[0] = const_cast<char*>("world");
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(5);
+    const size_t expectedSize = sizeofArray(1) + sizeofString(5);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should duplicate std::string") {
     array[0] = std::string("world");
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(5);
+    const size_t expectedSize = sizeofArray(1) + sizeofString(5);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 

extras/tests/JsonDeserializer/array.cpp

@@ -5,6 +5,10 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
+using ArduinoJson::detail::sizeofString;
+
 TEST_CASE("deserialize JSON array") {
   JsonDocument doc(4096);
 
@@ -248,13 +252,13 @@ TEST_CASE("deserialize JSON array") {
     JsonArray arr = doc.as<JsonArray>();
 
     REQUIRE(arr.size() == 0);
-    REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
+    REQUIRE(doc.memoryUsage() == sizeofArray(0));
   }
 }
 
 TEST_CASE("deserialize JSON array under memory constraints") {
   SECTION("buffer of the right size for an empty array") {
-    JsonDocument doc(JSON_ARRAY_SIZE(0));
+    JsonDocument doc(sizeofArray(0));
     char input[] = "[]";
 
     DeserializationError err = deserializeJson(doc, input);
@@ -263,7 +267,7 @@ TEST_CASE("deserialize JSON array under memory constraints") {
   }
 
   SECTION("buffer too small for an array with one element") {
-    JsonDocument doc(JSON_ARRAY_SIZE(0));
+    JsonDocument doc(sizeofArray(0));
     char input[] = "[1]";
 
     DeserializationError err = deserializeJson(doc, input);
@@ -272,7 +276,7 @@ TEST_CASE("deserialize JSON array under memory constraints") {
   }
 
   SECTION("buffer of the right size for an array with one element") {
-    JsonDocument doc(JSON_ARRAY_SIZE(1));
+    JsonDocument doc(sizeofArray(1));
     char input[] = "[1]";
 
     DeserializationError err = deserializeJson(doc, input);
@@ -281,7 +285,7 @@ TEST_CASE("deserialize JSON array under memory constraints") {
   }
 
   SECTION("buffer too small for an array with a nested object") {
-    JsonDocument doc(JSON_ARRAY_SIZE(0) + JSON_OBJECT_SIZE(0));
+    JsonDocument doc(sizeofArray(0) + sizeofObject(0));
     char input[] = "[{}]";
 
     DeserializationError err = deserializeJson(doc, input);
@@ -290,7 +294,7 @@ TEST_CASE("deserialize JSON array under memory constraints") {
   }
 
   SECTION("buffer of the right size for an array with a nested object") {
-    JsonDocument doc(JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(0));
+    JsonDocument doc(sizeofArray(1) + sizeofObject(0));
     char input[] = "[{}]";
 
     DeserializationError err = deserializeJson(doc, input);
@@ -303,13 +307,13 @@ TEST_CASE("deserialize JSON array under memory constraints") {
 
     deserializeJson(doc, "  [ \"1234567\" ] ");
 
-    REQUIRE(JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(7) == doc.memoryUsage());
+    REQUIRE(sizeofArray(1) + sizeofString(7) == doc.memoryUsage());
     // note: we use a string of 8 bytes to be sure that the MemoryPool
     // will not insert bytes to enforce alignement
   }
 
   SECTION("Should clear the JsonArray") {
-    JsonDocument doc(JSON_ARRAY_SIZE(4));
+    JsonDocument doc(sizeofArray(4));
     char input[] = "[1,2,3,4]";
 
     deserializeJson(doc, input);
@@ -317,11 +321,11 @@ TEST_CASE("deserialize JSON array under memory constraints") {
 
     JsonArray arr = doc.as<JsonArray>();
     REQUIRE(arr.size() == 0);
-    REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
+    REQUIRE(doc.memoryUsage() == sizeofArray(0));
   }
 
   SECTION("buffer of the right size for an array with two element") {
-    JsonDocument doc(JSON_ARRAY_SIZE(2));
+    JsonDocument doc(sizeofArray(2));
     char input[] = "[1,2]";
 
     DeserializationError err = deserializeJson(doc, input);
@@ -329,7 +333,7 @@ TEST_CASE("deserialize JSON array under memory constraints") {
 
     REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.is<JsonArray>());
-    REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2));
+    REQUIRE(doc.memoryUsage() == sizeofArray(2));
     REQUIRE(arr[0] == 1);
     REQUIRE(arr[1] == 2);
   }

extras/tests/JsonDeserializer/filter.cpp

@@ -9,6 +9,9 @@
 #include <sstream>
 #include <string>
 
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
+
 TEST_CASE("Filtering") {
   struct TestCase {
     const char* input;
@@ -43,7 +46,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"abcdefg\":\"hijklmn\"}",
-      JSON_OBJECT_SIZE(1) + 16
+      sizeofObject(1) + 16
     },
     {
       "{\"hello\":\"world\"}",
@@ -51,7 +54,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{}",
-      JSON_OBJECT_SIZE(0)
+      sizeofObject(0)
     },
     {
       // Input in an object, but filter wants an array
@@ -69,7 +72,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":null}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // Member is a number, but filter wants an array
@@ -78,7 +81,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":null}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // Input is an array, but filter wants an object
@@ -114,7 +117,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // skip a float
@@ -123,7 +126,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // skip false
@@ -132,7 +135,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // skip true
@@ -141,7 +144,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // skip null
@@ -150,7 +153,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // can skip a double-quoted string
@@ -159,7 +162,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // can skip a single-quoted string
@@ -168,7 +171,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // can skip an empty array
@@ -177,7 +180,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // can skip an empty array with spaces in it
@@ -186,7 +189,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // can skip an array
@@ -195,7 +198,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // can skip an array with spaces in it
@@ -204,7 +207,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // can skip an empty object
@@ -213,7 +216,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // can skip an empty object with spaces in it
@@ -222,7 +225,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // can skip an object
@@ -231,7 +234,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // skip an object with spaces in it
@@ -240,7 +243,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":42}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       "{\"an_integer\": 0,\"example\":{\"type\":\"int\",\"outcome\":42}}",
@@ -248,7 +251,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":{\"outcome\":42}}",
-      2 * JSON_OBJECT_SIZE(1) + 16
+      2 * sizeofObject(1) + 16
     },
     {
       // wildcard
@@ -257,7 +260,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":{\"outcome\":42}}",
-      2 * JSON_OBJECT_SIZE(1) + 16
+      2 * sizeofObject(1) + 16
     },
     {
       // exclusion filter (issue #1628)
@@ -266,7 +269,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{\"example\":1}",
-      JSON_OBJECT_SIZE(1) + 8
+      sizeofObject(1) + 8
     },
     {
       // only the first element of array counts
@@ -275,7 +278,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "[1,2,3]",
-      JSON_ARRAY_SIZE(3)
+      sizeofArray(3)
     },
     {
       // only the first element of array counts
@@ -284,7 +287,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "[]",
-      JSON_ARRAY_SIZE(0)
+      sizeofArray(0)
     },
     {
       // filter members of object in array
@@ -293,7 +296,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "[{\"example\":1},{\"example\":3}]",
-      JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 8
+      sizeofArray(2) + 2 * sizeofObject(1) + 8
     },
     {
       "[',2,3]",
@@ -301,7 +304,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::IncompleteInput,
       "[]",
-      JSON_ARRAY_SIZE(0)
+      sizeofArray(0)
     },
     {
       "[\",2,3]",
@@ -309,7 +312,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::IncompleteInput,
       "[]",
-      JSON_ARRAY_SIZE(0)
+      sizeofArray(0)
     },
     {
       // detect errors in skipped value
@@ -318,7 +321,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::InvalidInput,
       "[]",
-      JSON_ARRAY_SIZE(0)
+      sizeofArray(0)
     },
     {
       // detect incomplete string event if it's skipped
@@ -471,7 +474,7 @@ TEST_CASE("Filtering") {
       1,
       DeserializationError::TooDeep,
       "{}",
-      JSON_OBJECT_SIZE(0)
+      sizeofObject(0)
     },
     {
       // check nesting limit even for ignored arrays
@@ -498,7 +501,7 @@ TEST_CASE("Filtering") {
       1,
       DeserializationError::TooDeep,
       "[]",
-      JSON_ARRAY_SIZE(0)
+      sizeofArray(0)
     },
     {
       // supports back-slash at the end of skipped string
@@ -543,7 +546,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::InvalidInput,
       "[]",
-      JSON_ARRAY_SIZE(0)
+      sizeofArray(0)
     },
     {
       // incomplete comment at the begining of an array
@@ -552,7 +555,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::IncompleteInput,
       "[]",
-      JSON_ARRAY_SIZE(0)
+      sizeofArray(0)
     },
     {
       // invalid comment before key
@@ -561,7 +564,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::InvalidInput,
       "{}",
-      JSON_OBJECT_SIZE(0)
+      sizeofObject(0)
     },
     {
       // incomplete comment before key
@@ -570,7 +573,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::IncompleteInput,
       "{}",
-      JSON_OBJECT_SIZE(0)
+      sizeofObject(0)
     },
     {
       // invalid comment after key
@@ -579,7 +582,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::InvalidInput,
       "{}",
-      JSON_OBJECT_SIZE(0)
+      sizeofObject(0)
     },
     {
       // incomplete comment after key
@@ -588,7 +591,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::IncompleteInput,
       "{}",
-      JSON_OBJECT_SIZE(0)
+      sizeofObject(0)
     },
     {
       // invalid comment after colon
@@ -597,7 +600,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::InvalidInput,
       "{}",
-      JSON_OBJECT_SIZE(0)
+      sizeofObject(0)
     },
     {
       // incomplete comment after colon
@@ -606,7 +609,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::IncompleteInput,
       "{}",
-      JSON_OBJECT_SIZE(0)
+      sizeofObject(0)
     },
     {
       // comment next to an integer
@@ -615,7 +618,7 @@ TEST_CASE("Filtering") {
       10,
       DeserializationError::Ok,
       "{}",
-      JSON_OBJECT_SIZE(0)
+      sizeofObject(0)
     },
     {
       // invalid comment after opening brace of a skipped object

extras/tests/JsonDeserializer/input_types.cpp

@@ -9,6 +9,8 @@
 
 #include "CustomReader.hpp"
 
+using ArduinoJson::detail::sizeofObject;
+
 TEST_CASE("deserializeJson(char*)") {
   JsonDocument doc(1024);
 
@@ -18,9 +20,9 @@ TEST_CASE("deserializeJson(char*)") {
     DeserializationError err = deserializeJson(doc, input);
 
     REQUIRE(err == DeserializationError::Ok);
-    CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1));
+    CHECK(doc.memoryUsage() == sizeofObject(1));
     CHECK(doc.as<JsonVariant>().memoryUsage() ==
-          JSON_OBJECT_SIZE(1));  // issue #1318
+          sizeofObject(1));  // issue #1318
   }
 }
 
@@ -149,7 +151,7 @@ TEST_CASE("deserializeJson(VLA)") {
   char vla[i];
   strcpy(vla, "{\"a\":42}");
 
-  JsonDocument doc(JSON_OBJECT_SIZE(1));
+  JsonDocument doc(sizeofObject(1));
   DeserializationError err = deserializeJson(doc, vla);
 
   REQUIRE(err == DeserializationError::Ok);

extras/tests/JsonDeserializer/misc.cpp

@@ -7,6 +7,8 @@
 
 using namespace Catch::Matchers;
 
+using ArduinoJson::detail::sizeofObject;
+
 TEST_CASE("deserializeJson(JsonDocument&)") {
   JsonDocument doc(4096);
 
@@ -112,6 +114,6 @@ TEST_CASE("deserializeJson(JsonDocument&)") {
     deserializeJson(doc, "{}");
 
     REQUIRE(doc.is<JsonObject>());
-    REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
+    REQUIRE(doc.memoryUsage() == sizeofObject(0));
   }
 }

extras/tests/JsonDeserializer/object.cpp

@@ -5,6 +5,9 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
+
 TEST_CASE("deserialize JSON object") {
   JsonDocument doc(4096);
 
@@ -304,7 +307,7 @@ TEST_CASE("deserialize JSON object") {
 
     REQUIRE(doc.is<JsonObject>());
     REQUIRE(obj.size() == 0);
-    REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
+    REQUIRE(doc.memoryUsage() == sizeofObject(0));
   }
 
   SECTION("Issue #1335") {
@@ -316,7 +319,7 @@ TEST_CASE("deserialize JSON object") {
 
 TEST_CASE("deserialize JSON object under memory constraints") {
   SECTION("buffer for the right size for an empty object") {
-    JsonDocument doc(JSON_OBJECT_SIZE(0));
+    JsonDocument doc(sizeofObject(0));
     char input[] = "{}";
 
     DeserializationError err = deserializeJson(doc, input);
@@ -325,7 +328,7 @@ TEST_CASE("deserialize JSON object under memory constraints") {
   }
 
   SECTION("buffer too small for an empty object") {
-    JsonDocument doc(JSON_OBJECT_SIZE(0));
+    JsonDocument doc(sizeofObject(0));
     char input[] = "{\"a\":1}";
 
     DeserializationError err = deserializeJson(doc, input);
@@ -334,7 +337,7 @@ TEST_CASE("deserialize JSON object under memory constraints") {
   }
 
   SECTION("buffer of the right size for an object with one member") {
-    JsonDocument doc(JSON_OBJECT_SIZE(1));
+    JsonDocument doc(sizeofObject(1));
     char input[] = "{\"a\":1}";
 
     DeserializationError err = deserializeJson(doc, input);
@@ -343,7 +346,7 @@ TEST_CASE("deserialize JSON object under memory constraints") {
   }
 
   SECTION("buffer too small for an object with a nested array") {
-    JsonDocument doc(JSON_OBJECT_SIZE(0) + JSON_ARRAY_SIZE(0));
+    JsonDocument doc(sizeofObject(0) + sizeofArray(0));
     char input[] = "{\"a\":[]}";
 
     DeserializationError err = deserializeJson(doc, input);
@@ -352,7 +355,7 @@ TEST_CASE("deserialize JSON object under memory constraints") {
   }
 
   SECTION("buffer of the right size for an object with a nested array") {
-    JsonDocument doc(JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(0));
+    JsonDocument doc(sizeofObject(1) + sizeofArray(0));
     char input[] = "{\"a\":[]}";
 
     DeserializationError err = deserializeJson(doc, input);
@@ -361,13 +364,13 @@ TEST_CASE("deserialize JSON object under memory constraints") {
   }
 
   SECTION("Should clear the JsonObject") {
-    JsonDocument doc(JSON_OBJECT_SIZE(1));
+    JsonDocument doc(sizeofObject(1));
     char input[] = "{\"hello\":\"world\"}";
 
     deserializeJson(doc, input);
     deserializeJson(doc, "{}");
 
     REQUIRE(doc.as<JsonObject>().size() == 0);
-    REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
+    REQUIRE(doc.memoryUsage() == sizeofObject(0));
   }
 }

extras/tests/JsonDeserializer/string.cpp

@@ -6,6 +6,9 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofObject;
+using ArduinoJson::detail::sizeofString;
+
 TEST_CASE("Valid JSON strings value") {
   struct TestCase {
     const char* input;
@@ -93,7 +96,7 @@ TEST_CASE("Invalid JSON string") {
 }
 
 TEST_CASE("Not enough room to save the key") {
-  JsonDocument doc(JSON_OBJECT_SIZE(1) + 8);
+  JsonDocument doc(sizeofObject(1) + 8);
 
   SECTION("Quoted string") {
     REQUIRE(deserializeJson(doc, "{\"example\":1}") ==

extras/tests/JsonDocument/JsonDocument.cpp

@@ -6,6 +6,8 @@
 #include <catch.hpp>
 
 using ArduinoJson::detail::addPadding;
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
 
 static void REQUIRE_JSON(JsonDocument& doc, const std::string& expected) {
   std::string json;
@@ -31,19 +33,19 @@ TEST_CASE("JsonDocument") {
       REQUIRE(doc.memoryUsage() == 0);
     }
 
-    SECTION("JSON_ARRAY_SIZE(0)") {
+    SECTION("sizeofArray(0)") {
       doc.to<JsonArray>();
-      REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
+      REQUIRE(doc.memoryUsage() == sizeofArray(0));
     }
 
-    SECTION("JSON_ARRAY_SIZE(1)") {
+    SECTION("sizeofArray(1)") {
       doc.to<JsonArray>().add(42);
-      REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1));
+      REQUIRE(doc.memoryUsage() == sizeofArray(1));
     }
 
-    SECTION("JSON_ARRAY_SIZE(1) + JSON_ARRAY_SIZE(0)") {
+    SECTION("sizeofArray(1) + sizeofArray(0)") {
       doc.to<JsonArray>().createNestedArray();
-      REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1) + JSON_ARRAY_SIZE(0));
+      REQUIRE(doc.memoryUsage() == sizeofArray(1) + sizeofArray(0));
     }
   }
 
@@ -63,21 +65,21 @@ TEST_CASE("JsonDocument") {
     SECTION("Increases after adding value to array") {
       JsonArray arr = doc.to<JsonArray>();
 
-      REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
+      REQUIRE(doc.memoryUsage() == sizeofArray(0));
       arr.add(42);
-      REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1));
+      REQUIRE(doc.memoryUsage() == sizeofArray(1));
       arr.add(43);
-      REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2));
+      REQUIRE(doc.memoryUsage() == sizeofArray(2));
     }
 
     SECTION("Increases after adding value to object") {
       JsonObject obj = doc.to<JsonObject>();
 
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
+      REQUIRE(doc.memoryUsage() == sizeofObject(0));
       obj["a"] = 1;
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1));
+      REQUIRE(doc.memoryUsage() == sizeofObject(1));
       obj["b"] = 2;
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2));
+      REQUIRE(doc.memoryUsage() == sizeofObject(2));
     }
   }
 }

extras/tests/JsonDocument/allocator.cpp

@@ -8,6 +8,8 @@
 #include <sstream>
 #include <utility>
 
+using ArduinoJson::detail::sizeofObject;
+
 class SpyingAllocator : public Allocator {
  public:
   virtual ~SpyingAllocator() {}
@@ -165,13 +167,13 @@ TEST_CASE("JsonDocument's allocator") {
     SECTION("when allocation succeeds") {
       deserializeJson(doc, "{\"blanket\":1,\"dancing\":2}");
       REQUIRE(doc.capacity() == 4096);
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      REQUIRE(doc.memoryUsage() == sizeofObject(2) + 16);
       doc.remove("blanket");
 
       bool result = doc.garbageCollect();
 
       REQUIRE(result == true);
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+      REQUIRE(doc.memoryUsage() == sizeofObject(1) + 8);
       REQUIRE(doc.capacity() == 4096);
       REQUIRE(doc.as<std::string>() == "{\"dancing\":2}");
     }
@@ -179,14 +181,14 @@ TEST_CASE("JsonDocument's allocator") {
     SECTION("when allocation fails") {
       deserializeJson(doc, "{\"blanket\":1,\"dancing\":2}");
       REQUIRE(doc.capacity() == 4096);
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      REQUIRE(doc.memoryUsage() == sizeofObject(2) + 16);
       doc.remove("blanket");
       controllableAllocator.disable();
 
       bool result = doc.garbageCollect();
 
       REQUIRE(result == false);
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      REQUIRE(doc.memoryUsage() == sizeofObject(2) + 16);
       REQUIRE(doc.capacity() == 4096);
       REQUIRE(doc.as<std::string>() == "{\"dancing\":2}");
     }

extras/tests/JsonDocument/overflowed.cpp

@@ -5,6 +5,8 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+
 TEST_CASE("JsonDocument::overflowed()") {
   SECTION("returns false on a fresh object") {
     JsonDocument doc(0);
@@ -18,19 +20,19 @@ TEST_CASE("JsonDocument::overflowed()") {
   }
 
   SECTION("returns false after successful insertion") {
-    JsonDocument doc(JSON_ARRAY_SIZE(1));
+    JsonDocument doc(sizeofArray(1));
     doc.add(0);
     CHECK(doc.overflowed() == false);
   }
 
   SECTION("returns true after a failed string copy") {
-    JsonDocument doc(JSON_ARRAY_SIZE(1));
+    JsonDocument doc(sizeofArray(1));
     doc.add(std::string("example"));
     CHECK(doc.overflowed() == true);
   }
 
   SECTION("returns false after a successful string copy") {
-    JsonDocument doc(JSON_ARRAY_SIZE(1) + 8);
+    JsonDocument doc(sizeofArray(1) + 8);
     doc.add(std::string("example"));
     CHECK(doc.overflowed() == false);
   }
@@ -42,13 +44,13 @@ TEST_CASE("JsonDocument::overflowed()") {
   }
 
   SECTION("returns true after a failed deserialization") {
-    JsonDocument doc(JSON_ARRAY_SIZE(1));
+    JsonDocument doc(sizeofArray(1));
     deserializeJson(doc, "[\"example\"]");
     CHECK(doc.overflowed() == true);
   }
 
   SECTION("returns false after a successful deserialization") {
-    JsonDocument doc(JSON_ARRAY_SIZE(1) + 8);
+    JsonDocument doc(sizeofArray(1) + 8);
     deserializeJson(doc, "[\"example\"]");
     CHECK(doc.overflowed() == false);
   }
@@ -61,14 +63,14 @@ TEST_CASE("JsonDocument::overflowed()") {
   }
 
   SECTION("remains false after shrinkToFit()") {
-    JsonDocument doc(JSON_ARRAY_SIZE(1));
+    JsonDocument doc(sizeofArray(1));
     doc.add(0);
     doc.shrinkToFit();
     CHECK(doc.overflowed() == false);
   }
 
   SECTION("remains true after shrinkToFit()") {
-    JsonDocument doc(JSON_ARRAY_SIZE(1));
+    JsonDocument doc(sizeofArray(1));
     doc.add(0);
     doc.add(0);
     doc.shrinkToFit();
@@ -76,7 +78,7 @@ TEST_CASE("JsonDocument::overflowed()") {
   }
 
   SECTION("return false after garbageCollect()") {
-    JsonDocument doc(JSON_ARRAY_SIZE(1));
+    JsonDocument doc(sizeofArray(1));
     doc.add(0);
     doc.add(0);
     doc.garbageCollect();

extras/tests/JsonDocument/shrinkToFit.cpp

@@ -8,6 +8,9 @@
 #include <stdlib.h>  // malloc, free
 #include <string>
 
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
+
 class ArmoredAllocator : public Allocator {
  public:
   ArmoredAllocator() : _ptr(0), _size(0) {}
@@ -68,12 +71,12 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
 
   SECTION("empty object") {
     deserializeJson(doc, "{}");
-    testShrinkToFit(doc, "{}", JSON_OBJECT_SIZE(0));
+    testShrinkToFit(doc, "{}", sizeofObject(0));
   }
 
   SECTION("empty array") {
     deserializeJson(doc, "[]");
-    testShrinkToFit(doc, "[]", JSON_ARRAY_SIZE(0));
+    testShrinkToFit(doc, "[]", sizeofArray(0));
   }
 
   SECTION("linked string") {
@@ -98,43 +101,43 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
 
   SECTION("linked key") {
     doc["key"] = 42;
-    testShrinkToFit(doc, "{\"key\":42}", JSON_OBJECT_SIZE(1));
+    testShrinkToFit(doc, "{\"key\":42}", sizeofObject(1));
   }
 
   SECTION("owned key") {
     doc[std::string("abcdefg")] = 42;
-    testShrinkToFit(doc, "{\"abcdefg\":42}", JSON_OBJECT_SIZE(1) + 8);
+    testShrinkToFit(doc, "{\"abcdefg\":42}", sizeofObject(1) + 8);
   }
 
   SECTION("linked string in array") {
     doc.add("hello");
-    testShrinkToFit(doc, "[\"hello\"]", JSON_ARRAY_SIZE(1));
+    testShrinkToFit(doc, "[\"hello\"]", sizeofArray(1));
   }
 
   SECTION("owned string in array") {
     doc.add(std::string("abcdefg"));
-    testShrinkToFit(doc, "[\"abcdefg\"]", JSON_ARRAY_SIZE(1) + 8);
+    testShrinkToFit(doc, "[\"abcdefg\"]", sizeofArray(1) + 8);
   }
 
   SECTION("linked string in object") {
     doc["key"] = "hello";
-    testShrinkToFit(doc, "{\"key\":\"hello\"}", JSON_OBJECT_SIZE(1));
+    testShrinkToFit(doc, "{\"key\":\"hello\"}", sizeofObject(1));
   }
 
   SECTION("owned string in object") {
     doc["key"] = std::string("abcdefg");
-    testShrinkToFit(doc, "{\"key\":\"abcdefg\"}", JSON_ARRAY_SIZE(1) + 8);
+    testShrinkToFit(doc, "{\"key\":\"abcdefg\"}", sizeofArray(1) + 8);
   }
 
   SECTION("unaligned") {
     doc.add(std::string("?"));  // two bytes in the string pool
-    REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 2);
+    REQUIRE(doc.memoryUsage() == sizeofObject(1) + 2);
 
     doc.shrinkToFit();
 
     // the new capacity should be padded to align the pointers
-    REQUIRE(doc.capacity() == JSON_OBJECT_SIZE(1) + sizeof(void*));
-    REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 2);
+    REQUIRE(doc.capacity() == sizeofObject(1) + sizeof(void*));
+    REQUIRE(doc.memoryUsage() == sizeofObject(1) + 2);
     REQUIRE(doc[0] == "?");
   }
 }

extras/tests/JsonObject/copy.cpp

@@ -5,6 +5,8 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofObject;
+
 TEST_CASE("JsonObject::set()") {
   JsonDocument doc1(4096);
   JsonDocument doc2(4096);
@@ -72,7 +74,7 @@ TEST_CASE("JsonObject::set()") {
   }
 
   SECTION("destination too small to store the key") {
-    JsonDocument doc3(JSON_OBJECT_SIZE(1));
+    JsonDocument doc3(sizeofObject(1));
     JsonObject obj3 = doc3.to<JsonObject>();
 
     obj1[std::string("hello")] = "world";
@@ -84,7 +86,7 @@ TEST_CASE("JsonObject::set()") {
   }
 
   SECTION("destination too small to store the value") {
-    JsonDocument doc3(JSON_OBJECT_SIZE(1));
+    JsonDocument doc3(sizeofObject(1));
     JsonObject obj3 = doc3.to<JsonObject>();
 
     obj1["hello"] = std::string("world");

extras/tests/JsonObject/iterator.cpp

@@ -6,9 +6,10 @@
 #include <catch.hpp>
 
 using namespace Catch::Matchers;
+using ArduinoJson::detail::sizeofObject;
 
 TEST_CASE("JsonObject::begin()/end()") {
-  JsonDocument doc(JSON_OBJECT_SIZE(2));
+  JsonDocument doc(sizeofObject(2));
   JsonObject obj = doc.to<JsonObject>();
   obj["ab"] = 12;
   obj["cd"] = 34;
@@ -38,7 +39,7 @@ TEST_CASE("JsonObject::begin()/end()") {
 }
 
 TEST_CASE("JsonObjectConst::begin()/end()") {
-  JsonDocument doc(JSON_OBJECT_SIZE(2));
+  JsonDocument doc(sizeofObject(2));
   JsonObject obj = doc.to<JsonObject>();
   obj["ab"] = 12;
   obj["cd"] = 34;

extras/tests/JsonObject/memoryUsage.cpp

@@ -6,6 +6,9 @@
 #include <catch.hpp>
 #include <string>
 
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
+
 TEST_CASE("JsonObject::memoryUsage()") {
   JsonDocument doc(4096);
   JsonObject obj = doc.to<JsonObject>();
@@ -15,29 +18,29 @@ TEST_CASE("JsonObject::memoryUsage()") {
     REQUIRE(unitialized.memoryUsage() == 0);
   }
 
-  SECTION("JSON_OBJECT_SIZE(0) for empty object") {
-    REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(0));
+  SECTION("sizeofObject(0) for empty object") {
+    REQUIRE(obj.memoryUsage() == sizeofObject(0));
   }
 
-  SECTION("JSON_OBJECT_SIZE(1) after add") {
+  SECTION("sizeofObject(1) after add") {
     obj["hello"] = 42;
-    REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(1));
+    REQUIRE(obj.memoryUsage() == sizeofObject(1));
   }
 
   SECTION("includes the size of the key") {
     obj[std::string("hello")] = 42;
-    REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(1) + 6);
+    REQUIRE(obj.memoryUsage() == sizeofObject(1) + 6);
   }
 
   SECTION("includes the size of the nested array") {
     JsonArray nested = obj.createNestedArray("nested");
     nested.add(42);
-    REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(1));
+    REQUIRE(obj.memoryUsage() == sizeofObject(1) + sizeofArray(1));
   }
 
   SECTION("includes the size of the nested object") {
     JsonObject nested = obj.createNestedObject("nested");
     nested["hello"] = "world";
-    REQUIRE(obj.memoryUsage() == 2 * JSON_OBJECT_SIZE(1));
+    REQUIRE(obj.memoryUsage() == 2 * sizeofObject(1));
   }
 }

extras/tests/JsonObject/subscript.cpp

@@ -5,6 +5,9 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofObject;
+using ArduinoJson::detail::sizeofString;
+
 TEST_CASE("JsonObject::operator[]") {
   JsonDocument doc(4096);
   JsonObject obj = doc.to<JsonObject>();
@@ -100,55 +103,55 @@ TEST_CASE("JsonObject::operator[]") {
 
   SECTION("should not duplicate const char*") {
     obj["hello"] = "world";
-    const size_t expectedSize = JSON_OBJECT_SIZE(1);
+    const size_t expectedSize = sizeofObject(1);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should duplicate char* value") {
     obj["hello"] = const_cast<char*>("world");
-    const size_t expectedSize = JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(5);
+    const size_t expectedSize = sizeofObject(1) + sizeofString(5);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should duplicate char* key") {
     obj[const_cast<char*>("hello")] = "world";
-    const size_t expectedSize = JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(5);
+    const size_t expectedSize = sizeofObject(1) + sizeofString(5);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should duplicate char* key&value") {
     obj[const_cast<char*>("hello")] = const_cast<char*>("world");
-    const size_t expectedSize = JSON_OBJECT_SIZE(1) + 2 * JSON_STRING_SIZE(5);
+    const size_t expectedSize = sizeofObject(1) + 2 * sizeofString(5);
     REQUIRE(expectedSize <= doc.memoryUsage());
   }
 
   SECTION("should duplicate std::string value") {
     obj["hello"] = std::string("world");
-    const size_t expectedSize = JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(5);
+    const size_t expectedSize = sizeofObject(1) + sizeofString(5);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should duplicate std::string key") {
     obj[std::string("hello")] = "world";
-    const size_t expectedSize = JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(5);
+    const size_t expectedSize = sizeofObject(1) + sizeofString(5);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should duplicate std::string key&value") {
     obj[std::string("hello")] = std::string("world");
-    const size_t expectedSize = JSON_OBJECT_SIZE(1) + 2 * JSON_STRING_SIZE(5);
+    const size_t expectedSize = sizeofObject(1) + 2 * sizeofString(5);
     REQUIRE(expectedSize <= doc.memoryUsage());
   }
 
   SECTION("should duplicate a non-static JsonString key") {
     obj[JsonString("hello", JsonString::Copied)] = "world";
-    const size_t expectedSize = JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(5);
+    const size_t expectedSize = sizeofObject(1) + sizeofString(5);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 
   SECTION("should not duplicate a static JsonString key") {
     obj[JsonString("hello", JsonString::Linked)] = "world";
-    const size_t expectedSize = JSON_OBJECT_SIZE(1);
+    const size_t expectedSize = sizeofObject(1);
     REQUIRE(expectedSize == doc.memoryUsage());
   }
 

extras/tests/JsonSerializer/JsonArray.cpp

@@ -5,6 +5,8 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+
 static void check(JsonArray array, std::string expected) {
   std::string actual;
   size_t actualLen = serializeJson(array, actual);
@@ -15,7 +17,7 @@ static void check(JsonArray array, std::string expected) {
 }
 
 TEST_CASE("serializeJson(JsonArray)") {
-  JsonDocument doc(JSON_ARRAY_SIZE(2));
+  JsonDocument doc(sizeofArray(2));
   JsonArray array = doc.to<JsonArray>();
 
   SECTION("Empty") {

extras/tests/JsonVariant/copy.cpp

@@ -5,6 +5,8 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofString;
+
 TEST_CASE("JsonVariant::set(JsonVariant)") {
   JsonDocument doc1(4096);
   JsonDocument doc2(4096);
@@ -47,16 +49,16 @@ TEST_CASE("JsonVariant::set(JsonVariant)") {
     var1.set(str);
     var2.set(var1);
 
-    REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(7));
-    REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7));
+    REQUIRE(doc1.memoryUsage() == sizeofString(7));
+    REQUIRE(doc2.memoryUsage() == sizeofString(7));
   }
 
   SECTION("stores std::string by copy") {
     var1.set(std::string("hello!!"));
     var2.set(var1);
 
-    REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(7));
-    REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7));
+    REQUIRE(doc1.memoryUsage() == sizeofString(7));
+    REQUIRE(doc2.memoryUsage() == sizeofString(7));
   }
 
   SECTION("stores Serialized<const char*> by reference") {
@@ -72,16 +74,16 @@ TEST_CASE("JsonVariant::set(JsonVariant)") {
     var1.set(serialized(str, 7));
     var2.set(var1);
 
-    REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(7));
-    REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7));
+    REQUIRE(doc1.memoryUsage() == sizeofString(7));
+    REQUIRE(doc2.memoryUsage() == sizeofString(7));
   }
 
   SECTION("stores Serialized<std::string> by copy") {
     var1.set(serialized(std::string("hello!!")));
     var2.set(var1);
 
-    REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(7));
-    REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7));
+    REQUIRE(doc1.memoryUsage() == sizeofString(7));
+    REQUIRE(doc2.memoryUsage() == sizeofString(7));
   }
 
   SECTION("destination is unbound") {

extras/tests/JsonVariant/memoryUsage.cpp

@@ -6,6 +6,9 @@
 #include <catch.hpp>
 #include <string>
 
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
+
 TEST_CASE("JsonVariant::memoryUsage()") {
   JsonDocument doc(4096);
   JsonVariant var = doc.to<JsonVariant>();
@@ -18,13 +21,13 @@ TEST_CASE("JsonVariant::memoryUsage()") {
   SECTION("returns size of object") {
     JsonObject obj = var.to<JsonObject>();
     obj["hello"] = 42;
-    REQUIRE(var.memoryUsage() == JSON_OBJECT_SIZE(1));
+    REQUIRE(var.memoryUsage() == sizeofObject(1));
   }
 
   SECTION("returns size of array") {
     JsonArray arr = var.to<JsonArray>();
     arr.add(42);
-    REQUIRE(var.memoryUsage() == JSON_ARRAY_SIZE(1));
+    REQUIRE(var.memoryUsage() == sizeofArray(1));
   }
 
   SECTION("returns size of owned string") {

extras/tests/MemoryPool/StringCopier.cpp

@@ -9,7 +9,7 @@ using namespace ArduinoJson::detail;
 
 TEST_CASE("StringCopier") {
   SECTION("Works when buffer is big enough") {
-    MemoryPool pool(addPadding(JSON_STRING_SIZE(5)));
+    MemoryPool pool(addPadding(sizeofString(5)));
     StringCopier str(&pool);
 
     str.startString();
@@ -32,7 +32,7 @@ TEST_CASE("StringCopier") {
   }
 
   SECTION("Increases size of memory pool") {
-    MemoryPool pool(addPadding(JSON_STRING_SIZE(6)));
+    MemoryPool pool(addPadding(sizeofString(6)));
     StringCopier str(&pool);
 
     str.startString();

extras/tests/Misc/printable.cpp

@@ -8,6 +8,8 @@
 #define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1
 #include <ArduinoJson.h>
 
+using ArduinoJson::detail::sizeofArray;
+
 struct PrintOneCharacterAtATime {
   static size_t printStringTo(const std::string& s, Print& p) {
     size_t result = 0;
@@ -139,6 +141,6 @@ TEST_CASE("Printable") {
     REQUIRE(doc.size() == 2);
     CHECK(doc[0] == "Hello World!");
     CHECK(doc[1] == "Hello World!");
-    CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 13);
+    CHECK(doc.memoryUsage() == sizeofArray(2) + 13);
   }
 }

extras/tests/Misc/unsigned_char.cpp

@@ -9,11 +9,13 @@
 #  define CONFLICTS_WITH_BUILTIN_OPERATOR
 #endif
 
+using ArduinoJson::detail::sizeofObject;
+
 TEST_CASE("unsigned char[]") {
   SECTION("deserializeJson()") {
     unsigned char input[] = "{\"a\":42}";
 
-    JsonDocument doc(JSON_OBJECT_SIZE(1));
+    JsonDocument doc(sizeofObject(1));
     DeserializationError err = deserializeJson(doc, input);
 
     REQUIRE(err == DeserializationError::Ok);
@@ -22,7 +24,7 @@ TEST_CASE("unsigned char[]") {
   SECTION("deserializeMsgPack()") {
     unsigned char input[] = "\xDE\x00\x01\xA5Hello\xA5world";
 
-    JsonDocument doc(JSON_OBJECT_SIZE(2));
+    JsonDocument doc(sizeofObject(2));
     DeserializationError err = deserializeMsgPack(doc, input);
 
     REQUIRE(err == DeserializationError::Ok);
@@ -30,7 +32,7 @@ TEST_CASE("unsigned char[]") {
 
   SECTION("serializeMsgPack(unsigned char[])") {
     unsigned char buffer[32];
-    JsonDocument doc(JSON_OBJECT_SIZE(2));
+    JsonDocument doc(sizeofObject(2));
     doc["hello"] = "world";
 
     size_t n = serializeMsgPack(doc, buffer);
@@ -41,7 +43,7 @@ TEST_CASE("unsigned char[]") {
 
   SECTION("serializeMsgPack(unsigned char*)") {
     unsigned char buffer[32];
-    JsonDocument doc(JSON_OBJECT_SIZE(2));
+    JsonDocument doc(sizeofObject(2));
     doc["hello"] = "world";
 
     size_t n = serializeMsgPack(doc, buffer, sizeof(buffer));
@@ -52,7 +54,7 @@ TEST_CASE("unsigned char[]") {
 
   SECTION("serializeJson(unsigned char[])") {
     unsigned char buffer[32];
-    JsonDocument doc(JSON_OBJECT_SIZE(2));
+    JsonDocument doc(sizeofObject(2));
     doc["hello"] = "world";
 
     size_t n = serializeJson(doc, buffer);
@@ -63,7 +65,7 @@ TEST_CASE("unsigned char[]") {
 
   SECTION("serializeJson(unsigned char*)") {
     unsigned char buffer[32];
-    JsonDocument doc(JSON_OBJECT_SIZE(2));
+    JsonDocument doc(sizeofObject(2));
     doc["hello"] = "world";
 
     size_t n = serializeJson(doc, buffer, sizeof(buffer));
@@ -74,7 +76,7 @@ TEST_CASE("unsigned char[]") {
 
   SECTION("serializeJsonPretty(unsigned char[])") {
     unsigned char buffer[32];
-    JsonDocument doc(JSON_OBJECT_SIZE(2));
+    JsonDocument doc(sizeofObject(2));
     doc["hello"] = "world";
 
     size_t n = serializeJsonPretty(doc, buffer);
@@ -84,7 +86,7 @@ TEST_CASE("unsigned char[]") {
 
   SECTION("serializeJsonPretty(unsigned char*)") {
     unsigned char buffer[32];
-    JsonDocument doc(JSON_OBJECT_SIZE(2));
+    JsonDocument doc(sizeofObject(2));
     doc["hello"] = "world";
 
     size_t n = serializeJsonPretty(doc, buffer, sizeof(buffer));

extras/tests/MixedConfiguration/enable_string_deduplication_0.cpp

@@ -11,6 +11,9 @@
 
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
+
 TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
   JsonDocument doc(1024);
 
@@ -18,15 +21,14 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
     SECTION("Deduplicate values") {
       deserializeJson(doc, "[\"example\",\"example\"]");
 
-      CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofArray(2) + 16);
       CHECK(doc[0].as<const char*>() != doc[1].as<const char*>());
     }
 
     SECTION("Deduplicate keys") {
       deserializeJson(doc, "[{\"example\":1},{\"example\":2}]");
 
-      CHECK(doc.memoryUsage() ==
-            2 * JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == 2 * sizeofObject(1) + sizeofArray(2) + 16);
 
       const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
       const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@@ -41,7 +43,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
         doc.add(std::string("example"));
         doc.add(std::string("example"));
 
-        CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 16);
         CHECK(doc[0].as<const char*>() != doc[1].as<const char*>());
       }
 
@@ -50,7 +52,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
         doc.add(value);
         doc.add(value);
 
-        CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 16);
         CHECK(doc[0].as<const char*>() != doc[1].as<const char*>());
       }
 
@@ -58,7 +60,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
         doc.add(String("example"));
         doc.add(String("example"));
 
-        CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 16);
         CHECK(doc[0].as<const char*>() != doc[1].as<const char*>());
       }
 
@@ -66,7 +68,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
         doc.add(F("example"));
         doc.add(F("example"));
 
-        CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 16);
         CHECK(doc[0].as<const char*>() != doc[1].as<const char*>());
       }
     }
@@ -76,8 +78,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
         doc[0][std::string("example")] = 1;
         doc[1][std::string("example")] = 2;
 
-        CHECK(doc.memoryUsage() ==
-              JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 16);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 16);
 
         const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
         const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@@ -89,8 +90,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
         doc[0][key] = 1;
         doc[1][key] = 2;
 
-        CHECK(doc.memoryUsage() ==
-              JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 16);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 16);
 
         const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
         const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@@ -101,8 +101,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
         doc[0][String("example")] = 1;
         doc[1][String("example")] = 2;
 
-        CHECK(doc.memoryUsage() ==
-              JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 16);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 16);
 
         const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
         const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@@ -113,8 +112,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
         doc[0][F("example")] = 1;
         doc[1][F("example")] = 2;
 
-        CHECK(doc.memoryUsage() ==
-              JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 16);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 16);
 
         const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
         const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();

extras/tests/MixedConfiguration/enable_string_deduplication_1.cpp

@@ -11,6 +11,9 @@
 
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
+
 TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
   JsonDocument doc(1024);
 
@@ -18,15 +21,14 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
     SECTION("Deduplicate values") {
       deserializeJson(doc, "[\"example\",\"example\"]");
 
-      CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 8);
+      CHECK(doc.memoryUsage() == sizeofArray(2) + 8);
       CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
     }
 
     SECTION("Deduplicate keys") {
       deserializeJson(doc, "[{\"example\":1},{\"example\":2}]");
 
-      CHECK(doc.memoryUsage() ==
-            2 * JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(2) + 8);
+      CHECK(doc.memoryUsage() == 2 * sizeofObject(1) + sizeofArray(2) + 8);
 
       const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
       const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@@ -40,7 +42,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
         doc.add(std::string("example"));
         doc.add(std::string("example"));
 
-        CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 8);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 8);
         CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
       }
 
@@ -49,7 +51,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
         doc.add(value);
         doc.add(value);
 
-        CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 8);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 8);
         CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
       }
 
@@ -57,7 +59,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
         doc.add(String("example"));
         doc.add(String("example"));
 
-        CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 8);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 8);
         CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
       }
 
@@ -65,7 +67,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
         doc.add(F("example"));
         doc.add(F("example"));
 
-        CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 8);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 8);
         CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
       }
     }
@@ -75,8 +77,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
         doc[0][std::string("example")] = 1;
         doc[1][std::string("example")] = 2;
 
-        CHECK(doc.memoryUsage() ==
-              JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 8);
 
         const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
         const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@@ -88,8 +89,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
         doc[0][key] = 1;
         doc[1][key] = 2;
 
-        CHECK(doc.memoryUsage() ==
-              JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 8);
 
         const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
         const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@@ -100,8 +100,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
         doc[0][String("example")] = 1;
         doc[1][String("example")] = 2;
 
-        CHECK(doc.memoryUsage() ==
-              JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 8);
 
         const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
         const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@@ -112,8 +111,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
         doc[0][F("example")] = 1;
         doc[1][F("example")] = 2;
 
-        CHECK(doc.memoryUsage() ==
-              JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 8);
 
         const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
         const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();

extras/tests/MsgPackDeserializer/deserializeVariant.cpp

@@ -5,6 +5,10 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
+using ArduinoJson::detail::sizeofString;
+
 template <typename T>
 static void checkValue(const char* input, T expected) {
   JsonDocument doc(4096);
@@ -185,89 +189,88 @@ TEST_CASE("deserializeMsgPack() under memory constaints") {
   }
 
   SECTION("fixarray") {
-    checkError(JSON_ARRAY_SIZE(0), "\x90", DeserializationError::Ok);  // []
-    checkError(JSON_ARRAY_SIZE(0), "\x91\x01",
+    checkError(sizeofArray(0), "\x90", DeserializationError::Ok);  // []
+    checkError(sizeofArray(0), "\x91\x01",
                DeserializationError::NoMemory);  // [1]
-    checkError(JSON_ARRAY_SIZE(1), "\x91\x01",
+    checkError(sizeofArray(1), "\x91\x01",
                DeserializationError::Ok);  // [1]
-    checkError(JSON_ARRAY_SIZE(1), "\x92\x01\x02",
+    checkError(sizeofArray(1), "\x92\x01\x02",
                DeserializationError::NoMemory);  // [1,2]
   }
 
   SECTION("array 16") {
-    checkError(JSON_ARRAY_SIZE(0), "\xDC\x00\x00", DeserializationError::Ok);
-    checkError(JSON_ARRAY_SIZE(0), "\xDC\x00\x01\x01",
+    checkError(sizeofArray(0), "\xDC\x00\x00", DeserializationError::Ok);
+    checkError(sizeofArray(0), "\xDC\x00\x01\x01",
                DeserializationError::NoMemory);
-    checkError(JSON_ARRAY_SIZE(1), "\xDC\x00\x01\x01",
-               DeserializationError::Ok);
-    checkError(JSON_ARRAY_SIZE(1), "\xDC\x00\x02\x01\x02",
+    checkError(sizeofArray(1), "\xDC\x00\x01\x01", DeserializationError::Ok);
+    checkError(sizeofArray(1), "\xDC\x00\x02\x01\x02",
                DeserializationError::NoMemory);
   }
 
   SECTION("array 32") {
-    checkError(JSON_ARRAY_SIZE(0), "\xDD\x00\x00\x00\x00",
+    checkError(sizeofArray(0), "\xDD\x00\x00\x00\x00",
                DeserializationError::Ok);
-    checkError(JSON_ARRAY_SIZE(0), "\xDD\x00\x00\x00\x01\x01",
+    checkError(sizeofArray(0), "\xDD\x00\x00\x00\x01\x01",
                DeserializationError::NoMemory);
-    checkError(JSON_ARRAY_SIZE(1), "\xDD\x00\x00\x00\x01\x01",
+    checkError(sizeofArray(1), "\xDD\x00\x00\x00\x01\x01",
                DeserializationError::Ok);
-    checkError(JSON_ARRAY_SIZE(1), "\xDD\x00\x00\x00\x02\x01\x02",
+    checkError(sizeofArray(1), "\xDD\x00\x00\x00\x02\x01\x02",
                DeserializationError::NoMemory);
   }
 
   SECTION("fixmap") {
     SECTION("{}") {
-      checkError(JSON_OBJECT_SIZE(0), "\x80", DeserializationError::Ok);
+      checkError(sizeofObject(0), "\x80", DeserializationError::Ok);
     }
     SECTION("{H:1}") {
-      checkError(JSON_OBJECT_SIZE(0), "\x81\xA1H\x01",
+      checkError(sizeofObject(0), "\x81\xA1H\x01",
                  DeserializationError::NoMemory);
-      checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2), "\x81\xA1H\x01",
+      checkError(sizeofObject(1) + sizeofString(2), "\x81\xA1H\x01",
                  DeserializationError::Ok);
     }
     SECTION("{H:1,W:2}") {
-      checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2),
-                 "\x82\xA1H\x01\xA1W\x02", DeserializationError::NoMemory);
-      checkError(JSON_OBJECT_SIZE(2) + 2 * JSON_STRING_SIZE(2),
+      checkError(sizeofObject(1) + sizeofString(2), "\x82\xA1H\x01\xA1W\x02",
+                 DeserializationError::NoMemory);
+      checkError(sizeofObject(2) + 2 * sizeofString(2),
                  "\x82\xA1H\x01\xA1W\x02", DeserializationError::Ok);
     }
   }
 
   SECTION("map 16") {
     SECTION("{}") {
-      checkError(JSON_OBJECT_SIZE(0), "\xDE\x00\x00", DeserializationError::Ok);
+      checkError(sizeofObject(0), "\xDE\x00\x00", DeserializationError::Ok);
     }
     SECTION("{H:1}") {
-      checkError(JSON_OBJECT_SIZE(0), "\xDE\x00\x01\xA1H\x01",
+      checkError(sizeofObject(0), "\xDE\x00\x01\xA1H\x01",
                  DeserializationError::NoMemory);
-      checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2),
-                 "\xDE\x00\x01\xA1H\x01", DeserializationError::Ok);
+      checkError(sizeofObject(1) + sizeofString(2), "\xDE\x00\x01\xA1H\x01",
+                 DeserializationError::Ok);
     }
     SECTION("{H:1,W:2}") {
-      checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2),
+      checkError(sizeofObject(1) + sizeofString(2),
                  "\xDE\x00\x02\xA1H\x01\xA1W\x02",
                  DeserializationError::NoMemory);
-      checkError(JSON_OBJECT_SIZE(2) + 2 * JSON_OBJECT_SIZE(1),
+      checkError(sizeofObject(2) + 2 * sizeofObject(1),
                  "\xDE\x00\x02\xA1H\x01\xA1W\x02", DeserializationError::Ok);
     }
   }
 
   SECTION("map 32") {
     SECTION("{}") {
-      checkError(JSON_OBJECT_SIZE(0), "\xDF\x00\x00\x00\x00",
+      checkError(sizeofObject(0), "\xDF\x00\x00\x00\x00",
                  DeserializationError::Ok);
     }
     SECTION("{H:1}") {
-      checkError(JSON_OBJECT_SIZE(0), "\xDF\x00\x00\x00\x01\xA1H\x01",
+      checkError(sizeofObject(0), "\xDF\x00\x00\x00\x01\xA1H\x01",
                  DeserializationError::NoMemory);
-      checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2),
+      checkError(sizeofObject(1) + sizeofString(2),
                  "\xDF\x00\x00\x00\x01\xA1H\x01", DeserializationError::Ok);
     }
     SECTION("{H:1,W:2}") {
-      checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2),
+      checkError(sizeofObject(1) + sizeofString(2),
                  "\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02",
                  DeserializationError::NoMemory);
-      checkError(JSON_OBJECT_SIZE(2) + 2 * JSON_OBJECT_SIZE(1),
+      checkError(sizeofObject(2) + 2 * sizeofObject(1),
                  "\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02",
                  DeserializationError::Ok);
     }

extras/tests/MsgPackDeserializer/filter.cpp

@@ -26,7 +26,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::IncompleteInput);
         CHECK(doc.as<std::string>() == "{}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
+        CHECK(doc.memoryUsage() == sizeofObject(0));
       }
 
       SECTION("input truncated after inside skipped uint 8") {
@@ -35,7 +35,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::IncompleteInput);
         CHECK(doc.as<std::string>() == "{}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
+        CHECK(doc.memoryUsage() == sizeofObject(0));
       }
 
       SECTION("input truncated after before skipped string size") {
@@ -43,7 +43,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::IncompleteInput);
         CHECK(doc.as<std::string>() == "{}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
+        CHECK(doc.memoryUsage() == sizeofObject(0));
       }
 
       SECTION("input truncated after before skipped ext size") {
@@ -51,7 +51,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::IncompleteInput);
         CHECK(doc.as<std::string>() == "{}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
+        CHECK(doc.memoryUsage() == sizeofObject(0));
       }
 
       SECTION("skip nil") {
@@ -60,7 +60,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("reject 0xc1") {
@@ -76,7 +76,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip true") {
@@ -85,7 +85,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip positive fixint") {
@@ -94,7 +94,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip negative fixint") {
@@ -103,7 +103,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip uint 8") {
@@ -112,7 +112,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip int 8") {
@@ -121,7 +121,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip uint 16") {
@@ -130,7 +130,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip int 16") {
@@ -139,7 +139,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip uint 32") {
@@ -149,7 +149,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip int 32") {
@@ -159,7 +159,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip uint 64") {
@@ -170,7 +170,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip int 64") {
@@ -181,7 +181,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip float 32") {
@@ -191,7 +191,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip float 64") {
@@ -202,7 +202,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip fixstr") {
@@ -211,7 +211,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip str 8") {
@@ -220,7 +220,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip str 16") {
@@ -229,7 +229,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip str 32") {
@@ -239,7 +239,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip bin 8") {
@@ -248,7 +248,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip bin 16") {
@@ -257,7 +257,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip bin 32") {
@@ -267,7 +267,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip fixarray") {
@@ -276,7 +276,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip array 16") {
@@ -286,7 +286,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip array 32") {
@@ -299,7 +299,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip fixmap") {
@@ -309,7 +309,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip map 16") {
@@ -321,7 +321,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip map 32") {
@@ -335,7 +335,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip fixext 1") {
@@ -347,7 +347,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip fixext 2") {
@@ -359,7 +359,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip fixext 4") {
@@ -371,7 +371,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip fixext 8") {
@@ -383,7 +383,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip fixext 16") {
@@ -397,7 +397,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip ext 8") {
@@ -409,7 +409,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip ext 16") {
@@ -421,7 +421,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
 
       SECTION("skip ext 32") {
@@ -433,7 +433,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
+        CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
       }
     }
 
@@ -454,8 +454,7 @@ TEST_CASE("deserializeMsgPack() filter") {
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() ==
               "{\"onlyarr\":[{\"measure\":2},{\"measure\":4}],\"include\":42}");
-        CHECK(doc.memoryUsage() ==
-              JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(2) + 24);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(2) + 24);
       }
 
       SECTION("include array 16") {
@@ -470,8 +469,7 @@ TEST_CASE("deserializeMsgPack() filter") {
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() ==
               "{\"onlyarr\":[{\"measure\":2},{\"measure\":4}],\"include\":42}");
-        CHECK(doc.memoryUsage() ==
-              JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(2) + 24);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(2) + 24);
       }
 
       SECTION("include array 32") {
@@ -486,8 +484,7 @@ TEST_CASE("deserializeMsgPack() filter") {
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() ==
               "{\"onlyarr\":[{\"measure\":2},{\"measure\":4}],\"include\":42}");
-        CHECK(doc.memoryUsage() ==
-              JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(2) + 24);
+        CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(2) + 24);
       }
 
       SECTION("skip null") {
@@ -496,7 +493,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip false") {
@@ -505,7 +502,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip true") {
@@ -514,7 +511,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip positive fixint") {
@@ -523,7 +520,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip negative fixint") {
@@ -532,7 +529,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip uint 8") {
@@ -541,7 +538,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip uint 16") {
@@ -550,7 +547,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip uint 32") {
@@ -560,7 +557,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip uint 64") {
@@ -571,7 +568,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip int 8") {
@@ -580,7 +577,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip int 16") {
@@ -589,7 +586,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip int 32") {
@@ -599,7 +596,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip int 64") {
@@ -610,7 +607,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip float 32") {
@@ -620,7 +617,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip float 64") {
@@ -631,7 +628,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip fixstr") {
@@ -640,7 +637,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip str 8") {
@@ -662,7 +659,7 @@ TEST_CASE("deserializeMsgPack() filter") {
             doc, "\x82\xA7onlyarr\xdb\x00\x00\x00\x05hello\xA7include\x2A",
             filterOpt);
 
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip fixmap") {
@@ -672,7 +669,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip map 16") {
@@ -684,7 +681,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
 
       SECTION("skip map 32") {
@@ -698,7 +695,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
-        CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+        CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
       }
     }
   }
@@ -713,7 +710,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "[]");
-        CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
+        CHECK(doc.memoryUsage() == sizeofArray(0));
       }
     }
 
@@ -726,7 +723,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
         CHECK(error == DeserializationError::Ok);
         CHECK(doc.as<std::string>() == "[1,2,3]");
-        CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(3));
+        CHECK(doc.memoryUsage() == sizeofArray(3));
       }
     }
   }
@@ -747,8 +744,7 @@ TEST_CASE("deserializeMsgPack() filter") {
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() ==
             "{\"onlyobj\":{\"measure\":2},\"include\":42}");
-      CHECK(doc.memoryUsage() ==
-            JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(1) + 24);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + sizeofObject(1) + 24);
     }
 
     SECTION("include map 16") {
@@ -761,8 +757,7 @@ TEST_CASE("deserializeMsgPack() filter") {
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() ==
             "{\"onlyobj\":{\"measure\":2},\"include\":42}");
-      CHECK(doc.memoryUsage() ==
-            JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(1) + 24);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + sizeofObject(1) + 24);
     }
 
     SECTION("include map 32") {
@@ -776,8 +771,7 @@ TEST_CASE("deserializeMsgPack() filter") {
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() ==
             "{\"onlyobj\":{\"measure\":2},\"include\":42}");
-      CHECK(doc.memoryUsage() ==
-            JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(1) + 24);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + sizeofObject(1) + 24);
     }
 
     SECTION("skip null") {
@@ -786,7 +780,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip false") {
@@ -795,7 +789,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip true") {
@@ -804,7 +798,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip positive fixint") {
@@ -813,7 +807,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip negative fixint") {
@@ -822,7 +816,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip uint 8") {
@@ -831,7 +825,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip uint 16") {
@@ -840,7 +834,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip uint 32") {
@@ -849,7 +843,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip uint 64") {
@@ -860,7 +854,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip int 8") {
@@ -869,7 +863,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip int 16") {
@@ -878,7 +872,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip int 32") {
@@ -887,7 +881,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip int 64") {
@@ -898,7 +892,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip float 32") {
@@ -907,7 +901,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip float 64") {
@@ -918,7 +912,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip fixstr") {
@@ -927,7 +921,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip str 8") {
@@ -949,7 +943,7 @@ TEST_CASE("deserializeMsgPack() filter") {
           doc, "\x82\xA7onlyobj\xdb\x00\x00\x00\x05hello\xA7include\x2A",
           filterOpt);
 
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip fixarray") {
@@ -958,7 +952,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip array 16") {
@@ -969,7 +963,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
 
     SECTION("skip array 32") {
@@ -981,7 +975,7 @@ TEST_CASE("deserializeMsgPack() filter") {
 
       CHECK(error == DeserializationError::Ok);
       CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
-      CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
+      CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
     }
   }
 

extras/tests/MsgPackDeserializer/input_types.cpp

@@ -7,6 +7,8 @@
 
 #include "CustomReader.hpp"
 
+using ArduinoJson::detail::sizeofObject;
+
 TEST_CASE("deserializeMsgPack(const std::string&)") {
   JsonDocument doc(4096);
 
@@ -76,7 +78,7 @@ TEST_CASE("deserializeMsgPack(VLA)") {
   char vla[i];
   memcpy(vla, "\xDE\x00\x01\xA5Hello\xA5world", 15);
 
-  JsonDocument doc(JSON_OBJECT_SIZE(1));
+  JsonDocument doc(sizeofObject(1));
   DeserializationError err = deserializeMsgPack(doc, vla);
 
   REQUIRE(err == DeserializationError::Ok);

extras/tests/MsgPackSerializer/serializeArray.cpp

@@ -5,6 +5,8 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+using ArduinoJson::detail::sizeofArray;
+
 static void check(const JsonArray array, const char* expected_data,
                   size_t expected_len) {
   std::string expected(expected_data, expected_data + expected_len);
@@ -26,7 +28,7 @@ static void check(const JsonArray array, const std::string& expected) {
 }
 
 TEST_CASE("serialize MsgPack array") {
-  JsonDocument doc(JSON_ARRAY_SIZE(65536));
+  JsonDocument doc(sizeofArray(65536));
   JsonArray array = doc.to<JsonArray>();
 
   SECTION("empty") {

keywords.txt

@@ -1,8 +1,3 @@
-# Macros
-JSON_ARRAY_SIZE	KEYWORD2
-JSON_OBJECT_SIZE	KEYWORD2
-JSON_STRING_SIZE	KEYWORD2
-
 # Free functions
 deserializeJson	KEYWORD2
 deserializeMsgPack	KEYWORD2

src/ArduinoJson/Memory/MemoryPool.hpp

@@ -13,19 +13,22 @@
 
 #include <string.h>  // memmove
 
-#define JSON_STRING_SIZE(SIZE) (SIZE + 1)
+ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
-// Computes the size required to store an array in a JsonDocument.
-// https://arduinojson.org/v6/how-to/determine-the-capacity-of-the-jsondocument/
-#define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS) \
-  ((NUMBER_OF_ELEMENTS) * sizeof(ArduinoJson::detail::VariantSlot))
+// Returns the size (in bytes) of an array with n elements.
+constexpr size_t sizeofArray(size_t n) {
+  return n * sizeof(VariantSlot);
+}
 
-// Returns the size (in bytes) of an object with n elements.
-// Can be very handy to determine the size of a StaticMemoryPool.
-#define JSON_OBJECT_SIZE(NUMBER_OF_ELEMENTS) \
-  ((NUMBER_OF_ELEMENTS) * sizeof(ArduinoJson::detail::VariantSlot))
+// Returns the size (in bytes) of an object with n members.
+constexpr size_t sizeofObject(size_t n) {
+  return n * sizeof(VariantSlot);
+}
 
-ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
+// Returns the size (in bytes) of an string with n characters.
+constexpr size_t sizeofString(size_t n) {
+  return n + 1;
+}
 
 // _begin                                   _end
 // v                                           v