CollectionImpl: attach to VariantData* instead of CollectionData*

Author: bblanchon

src/ArduinoJson/Array/ArrayData.hpp

@@ -12,13 +12,30 @@ class ArrayImpl : public CollectionImpl {
  public:
   ArrayImpl() {}
 
-  ArrayImpl(CollectionData* data, ResourceManager* resources)
+  ArrayImpl(VariantData* data, ResourceManager* resources)
       : CollectionImpl(data, resources) {}
 
-  VariantData* addElement();
+  bool isNull() const {
+    return !data_ || data_->type != VariantType::Array;
+  }
+
+  VariantData* addElement() {
+    if (isNull())
+      return nullptr;
+    return addElement(data_, resources_);
+  }
+
+  static VariantData* addElement(VariantData*, ResourceManager*);
+
+  template <typename T>
+  bool addValue(const T& value) {
+    if (isNull())
+      return false;
+    return addValue(value, data_, resources_);
+  }
 
   template <typename T>
-  bool addValue(const T& value);
+  static bool addValue(const T& value, VariantData*, ResourceManager*);
 
   VariantData* getOrAddElement(size_t index);
 

src/ArduinoJson/Array/ArrayImpl.hpp

@@ -11,6 +11,9 @@
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
 inline ArrayImpl::iterator ArrayImpl::at(size_t index) const {
+  if (isNull())
+    return iterator();
+
   auto it = createIterator();
   while (!it.done() && index) {
     it.next(resources_);
@@ -19,14 +22,16 @@ inline ArrayImpl::iterator ArrayImpl::at(size_t index) const {
   return it;
 }
 
-inline VariantData* ArrayImpl::addElement() {
-  if (!data_)
-    return nullptr;
-  ARDUINOJSON_ASSERT(resources_ != nullptr);
-  auto slot = resources_->allocVariant();
+inline VariantData* ArrayImpl::addElement(VariantData* data,
+                                          ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->isArray());
+  ARDUINOJSON_ASSERT(resources != nullptr);
+
+  auto slot = resources->allocVariant();
   if (!slot)
     return nullptr;
-  CollectionImpl::appendOne(slot);
+  CollectionImpl::appendOne(slot, data, resources);
   return slot.ptr();
 }
 
@@ -57,19 +62,19 @@ inline void ArrayImpl::removeElement(size_t index) {
 }
 
 template <typename T>
-inline bool ArrayImpl::addValue(const T& value) {
-  if (!data_)
-    return false;
-  ARDUINOJSON_ASSERT(resources_ != nullptr);
-  auto slot = resources_->allocVariant();
+inline bool ArrayImpl::addValue(const T& value, VariantData* data,
+                                ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(resources != nullptr);
+  auto slot = resources->allocVariant();
   if (!slot)
     return false;
-  JsonVariant variant(slot.ptr(), resources_);
+  JsonVariant variant(slot.ptr(), resources);
   if (!variant.set(value)) {
-    resources_->freeVariant(slot);
+    resources->freeVariant(slot);
     return false;
   }
-  CollectionImpl::appendOne(slot);
+  CollectionImpl::appendOne(slot, data, resources);
   return true;
 }
 

src/ArduinoJson/Array/JsonArray.hpp

@@ -24,7 +24,7 @@ class JsonArray : public detail::VariantOperators<JsonArray> {
 
   // INTERNAL USE ONLY
   JsonArray(detail::VariantData* data, detail::ResourceManager* resources)
-      : impl_(detail::VariantImpl::asArray(data, resources)) {}
+      : impl_(data, resources) {}
 
   // INTERNAL USE ONLY
   JsonArray(const detail::ArrayImpl& impl) : impl_(impl) {}

src/ArduinoJson/Array/JsonArrayConst.hpp

@@ -38,7 +38,7 @@ class JsonArrayConst : public detail::VariantOperators<JsonArrayConst> {
 
   // INTERNAL USE ONLY
   JsonArrayConst(detail::VariantData* data, detail::ResourceManager* resources)
-      : impl_(detail::VariantImpl::asArray(data, resources)) {}
+      : impl_(data, resources) {}
 
   // INTERNAL USE ONLY
   JsonArrayConst(const detail::ArrayImpl& impl) : impl_(impl) {}

src/ArduinoJson/Collection/CollectionData.hpp

@@ -68,48 +68,63 @@ class CollectionIterator {
 
 class CollectionImpl {
  protected:
-  CollectionData* data_;
+  VariantData* data_;
   ResourceManager* resources_;
 
  public:
   using iterator = CollectionIterator;
 
   CollectionImpl() : data_(nullptr), resources_(nullptr) {}
 
-  CollectionImpl(CollectionData* data, ResourceManager* resources)
+  CollectionImpl(VariantData* data, ResourceManager* resources)
       : data_(data), resources_(resources) {}
 
   explicit operator bool() const {
-    return data_ != nullptr;
+    return data_ && data_->isCollection();
   }
 
   bool isNull() const {
-    return data_ == nullptr;
+    return !operator bool();
   }
 
   VariantData* getData() const {
-    void* data = data_;  // prevent warning cast-align
-    return reinterpret_cast<VariantData*>(data);
+    return data_;
   }
 
   ResourceManager* getResourceManager() const {
     return resources_;
   }
 
-  iterator createIterator() const;
+  iterator createIterator() const {
+    if (isNull())
+      return iterator();
+    return createIterator(data_, resources_);
+  }
+
+  static iterator createIterator(VariantData*, ResourceManager*);
 
   size_t size() const;
   size_t nesting() const;
 
-  void clear();
+  void clear() {
+    if (isNull())
+      return;
+    clear(data_, resources_);
+  }
+
+  static void clear(VariantData*, ResourceManager*);
 
   SlotId head() const {
-    return data_->head;
+    ARDUINOJSON_ASSERT(data_ != nullptr);
+    ARDUINOJSON_ASSERT(data_->isCollection());
+    return data_->content.asCollection.head;
   }
 
  protected:
-  void appendOne(Slot<VariantData> slot);
-  void appendPair(Slot<VariantData> key, Slot<VariantData> value);
+  static void appendOne(Slot<VariantData> slot, VariantData*, ResourceManager*);
+
+  static void appendPair(Slot<VariantData> key, Slot<VariantData> value,
+                         VariantData*, ResourceManager*);
 
   void removeOne(iterator it);
   void removePair(iterator it);

src/ArduinoJson/Collection/CollectionImpl.hpp

@@ -19,62 +19,82 @@ inline void CollectionIterator::next(const ResourceManager* resources) {
   currentId_ = nextId;
 }
 
-inline CollectionImpl::iterator CollectionImpl::createIterator() const {
-  if (!data_)
-    return iterator();
-  return iterator(resources_->getVariant(data_->head), data_->head);
+inline CollectionImpl::iterator CollectionImpl::createIterator(
+    VariantData* data, ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->isCollection());
+  ARDUINOJSON_ASSERT(resources != nullptr);
+  auto head = data->content.asCollection.head;
+  return iterator(resources->getVariant(head), head);
 }
 
-inline void CollectionImpl::appendOne(Slot<VariantData> slot) {
-  ARDUINOJSON_ASSERT(data_ != nullptr);
-  ARDUINOJSON_ASSERT(resources_ != nullptr);
+inline void CollectionImpl::appendOne(Slot<VariantData> slot, VariantData* data,
+                                      ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->isCollection());
+  ARDUINOJSON_ASSERT(resources != nullptr);
+
+  auto coll = &data->content.asCollection;
 
-  if (data_->tail != NULL_SLOT) {
-    auto tail = resources_->getVariant(data_->tail);
+  if (coll->tail != NULL_SLOT) {
+    auto tail = resources->getVariant(coll->tail);
     tail->next = slot.id();
-    data_->tail = slot.id();
+    coll->tail = slot.id();
   } else {
-    data_->head = slot.id();
-    data_->tail = slot.id();
+    coll->head = slot.id();
+    coll->tail = slot.id();
   }
 }
 
 inline void CollectionImpl::appendPair(Slot<VariantData> key,
-                                       Slot<VariantData> value) {
-  ARDUINOJSON_ASSERT(data_ != nullptr);
-  ARDUINOJSON_ASSERT(resources_ != nullptr);
+                                       Slot<VariantData> value,
+                                       VariantData* data,
+                                       ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(resources != nullptr);
 
   key->next = value.id();
 
-  if (data_->tail != NULL_SLOT) {
-    auto tail = resources_->getVariant(data_->tail);
+  auto coll = &data->content.asCollection;
+
+  if (coll->tail != NULL_SLOT) {
+    auto tail = resources->getVariant(coll->tail);
     tail->next = key.id();
-    data_->tail = value.id();
+    coll->tail = value.id();
   } else {
-    data_->head = key.id();
-    data_->tail = value.id();
+    coll->head = key.id();
+    coll->tail = value.id();
   }
 }
 
-inline void CollectionImpl::clear() {
-  if (!data_)
-    return;
-  auto next = data_->head;
+inline void CollectionImpl::clear(VariantData* data,
+                                  ResourceManager* resources) {
+  ARDUINOJSON_ASSERT(data != nullptr);
+  ARDUINOJSON_ASSERT(data->isCollection());
+  ARDUINOJSON_ASSERT(resources != nullptr);
+
+  auto coll = &data->content.asCollection;
+
+  auto next = coll->head;
   while (next != NULL_SLOT) {
     auto currId = next;
-    auto slot = resources_->getVariant(next);
+    auto slot = resources->getVariant(next);
     next = slot->next;
-    resources_->freeVariant({slot, currId});
+    resources->freeVariant({slot, currId});
   }
 
-  data_->head = NULL_SLOT;
-  data_->tail = NULL_SLOT;
+  coll->head = NULL_SLOT;
+  coll->tail = NULL_SLOT;
 }
 
 inline Slot<VariantData> CollectionImpl::getPreviousSlot(
     VariantData* target) const {
+  ARDUINOJSON_ASSERT(data_ != nullptr);
+  ARDUINOJSON_ASSERT(data_->isCollection());
+  ARDUINOJSON_ASSERT(resources_ != nullptr);
+
   auto prev = Slot<VariantData>();
-  auto currentId = data_->head;
+  auto currentId = data_->content.asCollection.head;
   while (currentId != NULL_SLOT) {
     auto currentSlot = resources_->getVariant(currentId);
     if (currentSlot == target)
@@ -91,12 +111,13 @@ inline void CollectionImpl::removeOne(iterator it) {
   auto curr = it.slot_;
   auto prev = getPreviousSlot(curr);
   auto next = curr->next;
+  auto coll = &data_->content.asCollection;
   if (prev)
     prev->next = next;
   else
-    data_->head = next;
+    coll->head = next;
   if (next == NULL_SLOT)
-    data_->tail = prev.id();
+    coll->tail = prev.id();
   resources_->freeVariant({it.slot_, it.currentId_});
 }
 
@@ -118,7 +139,7 @@ inline void CollectionImpl::removePair(ObjectImpl::iterator it) {
 }
 
 inline size_t CollectionImpl::nesting() const {
-  if (!data_)
+  if (!data_ || !data_->isCollection())
     return 0;
   size_t maxChildNesting = 0;
   for (auto it = createIterator(); !it.done(); it.next(resources_)) {

src/ArduinoJson/Json/JsonDeserializer.hpp

@@ -71,15 +71,13 @@ class JsonDeserializer {
     switch (current()) {
       case '[':
         if (filter.allowArray())
-          return parseArray(VariantImpl::toArray(variant, resources_), filter,
-                            nestingLimit);
+          return parseArray(variant, filter, nestingLimit);
         else
           return skipArray(nestingLimit);
 
       case '{':
         if (filter.allowObject())
-          return parseObject(VariantImpl::toObject(variant, resources_), filter,
-                             nestingLimit);
+          return parseObject(variant, filter, nestingLimit);
         else
           return skipObject(nestingLimit);
 
@@ -148,10 +146,12 @@ class JsonDeserializer {
 
   template <typename TFilter>
   DeserializationError::Code parseArray(
-      ArrayImpl array, TFilter filter,
+      VariantData* array, TFilter filter,
       DeserializationOption::NestingLimit nestingLimit) {
     DeserializationError::Code err;
 
+    array->toArray();
+
     if (nestingLimit.reached())
       return DeserializationError::TooDeep;
 
@@ -174,7 +174,7 @@ class JsonDeserializer {
     for (;;) {
       if (elementFilter.allow()) {
         // Allocate slot in array
-        VariantData* value = array.addElement();
+        VariantData* value = ArrayImpl::addElement(array, resources_);
         if (!value)
           return DeserializationError::NoMemory;
 
@@ -234,10 +234,12 @@ class JsonDeserializer {
 
   template <typename TFilter>
   DeserializationError::Code parseObject(
-      ObjectImpl object, TFilter filter,
+      VariantData* object, TFilter filter,
       DeserializationOption::NestingLimit nestingLimit) {
     DeserializationError::Code err;
 
+    object->toObject();
+
     if (nestingLimit.reached())
       return DeserializationError::TooDeep;
 
@@ -275,9 +277,10 @@ class JsonDeserializer {
       TFilter memberFilter = filter[key];
 
       if (memberFilter.allow()) {
-        auto member = object.getMember(adaptString(key));
+        auto member =
+            ObjectImpl::getMember(adaptString(key), object, resources_);
         if (!member) {
-          auto keyVariant = object.addPair(&member);
+          auto keyVariant = ObjectImpl::addPair(&member, object, resources_);
           if (!keyVariant)
             return DeserializationError::NoMemory;