Added string deduplication (closes #1303)

extras/tests/MemoryPool/CMakeLists.txt

@@ -4,8 +4,8 @@
 
 add_executable(MemoryPoolTests 
 	allocVariant.cpp
-	allocString.cpp
 	clear.cpp
+	saveString.cpp
 	size.cpp
 	StringCopier.cpp
 )

extras/tests/MemoryPool/StringCopier.cpp

@@ -38,8 +38,47 @@ TEST_CASE("StringCopier") {
 
     str.startString(&pool);
     str.append('h');
-    str.commit(&pool);
+    str.save(&pool);
 
     REQUIRE(1 == pool.size());
   }
 }
+
+static const char* addStringToPool(MemoryPool* pool, const char* s) {
+  StringCopier str;
+  str.startString(pool);
+  str.append(s);
+  str.append('\0');
+  return str.save(pool);
+}
+
+TEST_CASE("StringCopier::save() deduplicates strings") {
+  char buffer[4096];
+  MemoryPool pool(buffer, 4096);
+
+  SECTION("Basic") {
+    const char* s1 = addStringToPool(&pool, "hello");
+    const char* s2 = addStringToPool(&pool, "world");
+    const char* s3 = addStringToPool(&pool, "hello");
+
+    REQUIRE(s1 == s3);
+    REQUIRE(s2 != s3);
+    REQUIRE(pool.size() == 12);
+  }
+
+  SECTION("Requires terminator") {
+    const char* s1 = addStringToPool(&pool, "hello world");
+    const char* s2 = addStringToPool(&pool, "hello");
+
+    REQUIRE(s2 != s1);
+    REQUIRE(pool.size() == 12 + 6);
+  }
+
+  SECTION("Don't overrun") {
+    const char* s1 = addStringToPool(&pool, "hello world");
+    const char* s2 = addStringToPool(&pool, "wor");
+
+    REQUIRE(s2 != s1);
+    REQUIRE(pool.size() == 12 + 4);
+  }
+}

extras/tests/MemoryPool/allocString.cpp

@@ -1,67 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson/Memory/MemoryPool.hpp>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("MemoryPool::allocFrozenString()") {
-  const size_t poolCapacity = 64;
-  const size_t longestString = poolCapacity;
-  char buffer[poolCapacity];
-  MemoryPool pool(buffer, poolCapacity);
-
-  SECTION("Returns different addresses") {
-    char *a = pool.allocFrozenString(1);
-    char *b = pool.allocFrozenString(1);
-    REQUIRE(a != b);
-  }
-
-  SECTION("Returns NULL when full") {
-    void *p1 = pool.allocFrozenString(longestString);
-    REQUIRE(p1 != 0);
-
-    void *p2 = pool.allocFrozenString(1);
-    REQUIRE(p2 == 0);
-  }
-
-  SECTION("Returns NULL when pool is too small") {
-    void *p = pool.allocFrozenString(longestString + 1);
-    REQUIRE(0 == p);
-  }
-
-  SECTION("Returns NULL when buffer is NULL") {
-    MemoryPool pool2(0, poolCapacity);
-    REQUIRE(0 == pool2.allocFrozenString(2));
-  }
-
-  SECTION("Returns NULL when capacity is 0") {
-    MemoryPool pool2(buffer, 0);
-    REQUIRE(0 == pool2.allocFrozenString(2));
-  }
-
-  SECTION("Returns same address after clear()") {
-    void *a = pool.allocFrozenString(1);
-    pool.clear();
-    void *b = pool.allocFrozenString(1);
-
-    REQUIRE(a == b);
-  }
-
-  SECTION("Can use full capacity when fresh") {
-    void *a = pool.allocFrozenString(longestString);
-
-    REQUIRE(a != 0);
-  }
-
-  SECTION("Can use full capacity after clear") {
-    pool.allocFrozenString(longestString);
-    pool.clear();
-
-    void *a = pool.allocFrozenString(longestString);
-
-    REQUIRE(a != 0);
-  }
-}

extras/tests/MemoryPool/clear.cpp

@@ -3,6 +3,7 @@
 // MIT License
 
 #include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
 #include <catch.hpp>
 
 using namespace ARDUINOJSON_NAMESPACE;
@@ -21,8 +22,8 @@ TEST_CASE("MemoryPool::clear()") {
   }
 
   SECTION("Discards allocated strings") {
-    pool.allocFrozenString(10);
-    REQUIRE(pool.size() > 0);
+    pool.saveString(adaptString(const_cast<char *>("123456789")));
+    REQUIRE(pool.size() == 10);
 
     pool.clear();
 

extras/tests/MemoryPool/saveString.cpp

@@ -0,0 +1,81 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2020
+// MIT License
+
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <ArduinoJson/Strings/StringAdapters.hpp>
+#include <catch.hpp>
+
+using namespace ARDUINOJSON_NAMESPACE;
+
+static const char *saveString(MemoryPool &pool, const char *s) {
+  return pool.saveString(adaptString(const_cast<char *>(s)));
+}
+
+TEST_CASE("MemoryPool::saveString()") {
+  char buffer[32];
+  MemoryPool pool(buffer, 32);
+
+  SECTION("Duplicates different strings") {
+    const char *a = saveString(pool, "hello");
+    const char *b = saveString(pool, "world");
+    REQUIRE(a != b);
+    REQUIRE(pool.size() == 6 + 6);
+  }
+
+  SECTION("Deduplicates identical strings") {
+    const char *a = saveString(pool, "hello");
+    const char *b = saveString(pool, "hello");
+    REQUIRE(a == b);
+    REQUIRE(pool.size() == 6);
+  }
+
+  SECTION("Returns NULL when full") {
+    REQUIRE(pool.capacity() == 32);
+
+    const void *p1 = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+    REQUIRE(p1 != 0);
+    REQUIRE(pool.size() == 32);
+
+    const void *p2 = saveString(pool, "b");
+    REQUIRE(p2 == 0);
+  }
+
+  SECTION("Returns NULL when pool is too small") {
+    const void *p = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+    REQUIRE(0 == p);
+  }
+
+  SECTION("Returns NULL when buffer is NULL") {
+    MemoryPool pool2(0, 32);
+    REQUIRE(0 == saveString(pool2, "a"));
+  }
+
+  SECTION("Returns NULL when capacity is 0") {
+    MemoryPool pool2(buffer, 0);
+    REQUIRE(0 == saveString(pool2, "a"));
+  }
+
+  SECTION("Returns same address after clear()") {
+    const void *a = saveString(pool, "hello");
+    pool.clear();
+    const void *b = saveString(pool, "world");
+
+    REQUIRE(a == b);
+  }
+
+  SECTION("Can use full capacity when fresh") {
+    const void *a = saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+
+    REQUIRE(a != 0);
+  }
+
+  SECTION("Can use full capacity after clear") {
+    saveString(pool, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+    pool.clear();
+
+    const void *a = saveString(pool, "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+
+    REQUIRE(a != 0);
+  }
+}

extras/tests/MemoryPool/size.cpp

@@ -22,24 +22,6 @@ TEST_CASE("MemoryPool::size()") {
     REQUIRE(0 == pool.size());
   }
 
-  SECTION("Decreases after freezeString()") {
-    StringSlot a = pool.allocExpandableString();
-    pool.freezeString(a, 1);
-    REQUIRE(pool.size() == 1);
-
-    StringSlot b = pool.allocExpandableString();
-    pool.freezeString(b, 1);
-    REQUIRE(pool.size() == 2);
-  }
-
-  SECTION("Increases after allocFrozenString()") {
-    pool.allocFrozenString(1);
-    REQUIRE(pool.size() == 1);
-
-    pool.allocFrozenString(2);
-    REQUIRE(pool.size() == 3);
-  }
-
   SECTION("Doesn't grow when memory pool is full") {
     const size_t variantCount = sizeof(buffer) / sizeof(VariantSlot);