VariantPool: store VariantSlots instead of chars

src/ArduinoJson/Collection/CollectionImpl.hpp

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <ArduinoJson/Collection/CollectionData.hpp>
+#include <ArduinoJson/Memory/Alignment.hpp>
 #include <ArduinoJson/Strings/StringAdapters.hpp>
 #include <ArduinoJson/Variant/VariantCompare.hpp>
 #include <ArduinoJson/Variant/VariantData.hpp>

src/ArduinoJson/Memory/ResourceManager.hpp

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <ArduinoJson/Memory/Alignment.hpp>
 #include <ArduinoJson/Memory/Allocator.hpp>
 #include <ArduinoJson/Memory/StringPool.hpp>
 #include <ArduinoJson/Memory/VariantPool.hpp>
@@ -22,7 +21,7 @@ class ResourceManager {
   ResourceManager(size_t capa,
                   Allocator* allocator = DefaultAllocator::instance())
       : allocator_(allocator), overflowed_(false) {
-    variantPool_.create(addPadding(capa), allocator);
+    variantPool_.create(capa, allocator);
   }
 
   ~ResourceManager() {
@@ -48,8 +47,8 @@ class ResourceManager {
   }
 
   void reallocPool(size_t requiredSize) {
-    size_t capa = addPadding(requiredSize);
-    if (capa == capacity())
+    size_t capa = VariantPool::bytesToSlots(requiredSize);
+    if (capa == variantPool_.capacity())
       return;
     variantPool_.destroy(allocator_);
     variantPool_.create(requiredSize, allocator_);
@@ -57,11 +56,11 @@ class ResourceManager {
 
   // Gets the capacity of the memoryPool in bytes
   size_t capacity() const {
-    return variantPool_.capacity();
+    return VariantPool::slotsToBytes(variantPool_.capacity());
   }
 
   size_t size() const {
-    return variantPool_.usage() + stringPool_.size();
+    return VariantPool::slotsToBytes(variantPool_.usage()) + stringPool_.size();
   }
 
   bool overflowed() const {

src/ArduinoJson/Memory/VariantPool.hpp

@@ -14,7 +14,7 @@ class VariantSlot;
 class VariantPool {
  public:
   ~VariantPool() {
-    ARDUINOJSON_ASSERT(data_ == nullptr);
+    ARDUINOJSON_ASSERT(slots_ == nullptr);
   }
 
   VariantPool& operator=(VariantPool&& src) {
@@ -22,8 +22,8 @@ class VariantPool {
     src.capacity_ = 0;
     usage_ = src.usage_;
     src.usage_ = 0;
-    data_ = src.data_;
-    src.data_ = nullptr;
+    slots_ = src.slots_;
+    src.slots_ = nullptr;
     return *this;
   }
 
@@ -36,12 +36,13 @@ class VariantPool {
   size_t capacity() const;
   size_t usage() const;
 
-  static size_t sizeForCapacity(size_t);
+  static size_t bytesToSlots(size_t);
+  static size_t slotsToBytes(size_t);
 
  private:
   size_t capacity_ = 0;
   size_t usage_ = 0;
-  char* data_ = nullptr;
+  VariantSlot* slots_ = nullptr;
 };
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Memory/VariantPoolImpl.hpp

@@ -10,40 +10,40 @@
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
 inline void VariantPool::create(size_t cap, Allocator* allocator) {
-  ARDUINOJSON_ASSERT(data_ == nullptr);
+  ARDUINOJSON_ASSERT(slots_ == nullptr);
   if (!cap)
     return;
-  data_ = reinterpret_cast<char*>(allocator->allocate(cap));
-  if (data_) {
-    capacity_ = cap;
+  slots_ = reinterpret_cast<VariantSlot*>(allocator->allocate(cap));
+  if (slots_) {
+    capacity_ = bytesToSlots(cap);
     usage_ = 0;
   }
 }
 
 inline void VariantPool::destroy(Allocator* allocator) {
-  if (data_)
-    allocator->deallocate(data_);
-  data_ = nullptr;
+  if (slots_)
+    allocator->deallocate(slots_);
+  slots_ = nullptr;
   capacity_ = 0;
   usage_ = 0;
 }
 
 inline ptrdiff_t VariantPool::shrinkToFit(Allocator* allocator) {
-  auto originalPool = data_;
-  data_ = reinterpret_cast<char*>(allocator->reallocate(data_, usage_));
-  if (data_)
+  auto originalPool = slots_;
+  slots_ = reinterpret_cast<VariantSlot*>(
+      allocator->reallocate(slots_, slotsToBytes(usage_)));
+  if (slots_)
     capacity_ = usage_;
-  return data_ - originalPool;
+  return reinterpret_cast<char*>(slots_) -
+         reinterpret_cast<char*>(originalPool);
 }
 
 inline VariantSlot* VariantPool::allocVariant() {
-  if (!data_)
+  if (!slots_)
     return nullptr;
-  if (usage_ + sizeof(VariantSlot) > capacity_)
+  if (usage_ + 1 > capacity_)
     return nullptr;
-  auto p = data_ + usage_;
-  usage_ += sizeof(VariantSlot);
-  return new (p) VariantSlot;
+  return new (&slots_[usage_++]) VariantSlot;
 }
 
 inline size_t VariantPool::usage() const {
@@ -58,4 +58,12 @@ inline void VariantPool::clear() {
   usage_ = 0;
 }
 
+inline size_t VariantPool::bytesToSlots(size_t n) {
+  return n / sizeof(VariantSlot);
+}
+
+inline size_t VariantPool::slotsToBytes(size_t n) {
+  return n * sizeof(VariantSlot);
+}
+
 ARDUINOJSON_END_PRIVATE_NAMESPACE