Extracted VariantData and CollectionData classes

src/ArduinoJson/Array/ArrayFunctions.hpp

@@ -4,92 +4,26 @@
 
 #pragma once
 
-#include "../Variant/SlotFunctions.hpp"
-#include "../Variant/VariantData.hpp"
+#include "../Collection/CollectionData.hpp"
 
 namespace ARDUINOJSON_NAMESPACE {
 
-inline VariantData* arrayAdd(ArrayData* arr, MemoryPool* pool) {
-  if (!arr) return 0;
-
-  VariantSlot* slot = pool->allocVariant();
-  if (!slot) return 0;
-
-  slot->init();
-
-  if (arr->tail) {
-    slot->attachTo(arr->tail);
-    arr->tail = slot;
-  } else {
-    arr->head = slot;
-    arr->tail = slot;
-  }
-
-  return slot->getData();
+inline VariantData *arrayAdd(CollectionData *arr, MemoryPool *pool) {
+  return arr ? arr->add(pool) : 0;
 }
 
-inline VariantSlot* arrayGetSlot(const ArrayData* arr, size_t index) {
-  if (!arr) return 0;
-  return arr->head->getNext(index);
-}
-
-inline VariantData* arrayGet(const ArrayData* arr, size_t index) {
-  VariantSlot* slot = arrayGetSlot(arr, index);
-  return slot ? slot->getData() : 0;
-}
-
-inline void arrayRemove(ArrayData* arr, VariantSlot* slot) {
-  if (!arr || !slot) return;
-
-  VariantSlot* prev = slot->getPrev(arr->head);
-  VariantSlot* next = slot->getNext();
-
-  if (prev)
-    prev->setNext(next);
+template <typename Visitor>
+inline void arrayAccept(const CollectionData *arr, Visitor &visitor) {
+  if (arr)
+    visitor.visitArray(*arr);
   else
-    arr->head = next;
-  if (!next) arr->tail = prev;
+    visitor.visitNull();
 }
 
-inline void arrayRemove(ArrayData* arr, size_t index) {
-  arrayRemove(arr, arrayGetSlot(arr, index));
-}
+inline bool arrayEquals(const CollectionData *lhs, const CollectionData *rhs) {
+  if (lhs == rhs) return true;
+  if (!lhs || !rhs) return false;
 
-inline void arrayClear(ArrayData* arr) {
-  if (!arr) return;
-  arr->head = 0;
-  arr->tail = 0;
-}
-
-bool variantCopy(VariantData*, const VariantData*, MemoryPool*);
-
-inline bool arrayCopy(ArrayData* dst, const ArrayData* src, MemoryPool* pool) {
-  if (!dst || !src) return false;
-  arrayClear(dst);
-  for (VariantSlot* s = src->head; s; s = s->getNext()) {
-    if (!variantCopy(arrayAdd(dst, pool), s->getData(), pool)) return false;
-  }
-  return true;
-}
-
-bool variantEquals(const VariantData*, const VariantData*);
-
-inline bool arrayEquals(const ArrayData* a1, const ArrayData* a2) {
-  if (a1 == a2) return true;
-  if (!a1 || !a2) return false;
-  VariantSlot* s1 = a1->head;
-  VariantSlot* s2 = a2->head;
-  for (;;) {
-    if (s1 == s2) return true;
-    if (!s1 || !s2) return false;
-    if (!variantEquals(s1->getData(), s2->getData())) return false;
-    s1 = s1->getNext();
-    s2 = s2->getNext();
-  }
-}
-
-inline size_t arraySize(const ArrayData* arr) {
-  if (!arr) return 0;
-  return slotSize(arr->head);
+  return lhs->equalsArray(*rhs);
 }
 }  // namespace ARDUINOJSON_NAMESPACE

src/ArduinoJson/Array/ArrayIterator.hpp

@@ -11,8 +11,7 @@ namespace ARDUINOJSON_NAMESPACE {
 
 class VariantPtr {
  public:
-  VariantPtr(MemoryPool *memoryPool, VariantData *data)
-      : _variant(memoryPool, data) {}
+  VariantPtr(MemoryPool *pool, VariantData *data) : _variant(pool, data) {}
 
   VariantRef *operator->() {
     return &_variant;
@@ -29,14 +28,14 @@ class VariantPtr {
 class ArrayIterator {
  public:
   ArrayIterator() : _slot(0) {}
-  explicit ArrayIterator(MemoryPool *memoryPool, VariantSlot *slot)
-      : _memoryPool(memoryPool), _slot(slot) {}
+  explicit ArrayIterator(MemoryPool *pool, VariantSlot *slot)
+      : _pool(pool), _slot(slot) {}
 
   VariantRef operator*() const {
-    return VariantRef(_memoryPool, _slot->getData());
+    return VariantRef(_pool, _slot->data());
   }
   VariantPtr operator->() {
-    return VariantPtr(_memoryPool, _slot->getData());
+    return VariantPtr(_pool, _slot->data());
   }
 
   bool operator==(const ArrayIterator &other) const {
@@ -48,12 +47,12 @@ class ArrayIterator {
   }
 
   ArrayIterator &operator++() {
-    _slot = _slot->getNext();
+    _slot = _slot->next();
     return *this;
   }
 
   ArrayIterator &operator+=(size_t distance) {
-    _slot = _slot->getNext(distance);
+    _slot = _slot->next(distance);
     return *this;
   }
 
@@ -62,7 +61,7 @@ class ArrayIterator {
   }
 
  private:
-  MemoryPool *_memoryPool;
+  MemoryPool *_pool;
   VariantSlot *_slot;
 };
 
@@ -88,10 +87,10 @@ class ArrayConstRefIterator {
   explicit ArrayConstRefIterator(const VariantSlot *slot) : _slot(slot) {}
 
   VariantConstRef operator*() const {
-    return VariantConstRef(_slot->getData());
+    return VariantConstRef(_slot->data());
   }
   VariantConstPtr operator->() {
-    return VariantConstPtr(_slot->getData());
+    return VariantConstPtr(_slot->data());
   }
 
   bool operator==(const ArrayConstRefIterator &other) const {
@@ -103,12 +102,12 @@ class ArrayConstRefIterator {
   }
 
   ArrayConstRefIterator &operator++() {
-    _slot = _slot->getNext();
+    _slot = _slot->next();
     return *this;
   }
 
   ArrayConstRefIterator &operator+=(size_t distance) {
-    _slot = _slot->getNext(distance);
+    _slot = _slot->next(distance);
     return *this;
   }
 

src/ArduinoJson/Array/ArrayRef.hpp

@@ -21,16 +21,21 @@ class ArraySubscript;
 template <typename TData>
 class ArrayRefBase {
  public:
+  template <typename Visitor>
+  FORCE_INLINE void accept(Visitor& visitor) const {
+    arrayAccept(_data, visitor);
+  }
+
   FORCE_INLINE bool isNull() const {
     return _data == 0;
   }
 
   FORCE_INLINE VariantConstRef operator[](size_t index) const {
-    return VariantConstRef(arrayGet(_data, index));
+    return VariantConstRef(_data ? _data->get(index) : 0);
   }
 
   FORCE_INLINE size_t size() const {
-    return arraySize(_data);
+    return _data ? _data->size() : 0;
   }
 
  protected:
@@ -38,24 +43,17 @@ class ArrayRefBase {
   TData* _data;
 };
 
-class ArrayConstRef : public ArrayRefBase<const ArrayData>, public Visitable {
+class ArrayConstRef : public ArrayRefBase<const CollectionData>,
+                      public Visitable {
   friend class ArrayRef;
-  typedef ArrayRefBase<const ArrayData> base_type;
+  typedef ArrayRefBase<const CollectionData> base_type;
 
  public:
   typedef ArrayConstRefIterator iterator;
 
-  template <typename Visitor>
-  FORCE_INLINE void accept(Visitor& visitor) const {
-    if (_data)
-      visitor.visitArray(*this);
-    else
-      visitor.visitNull();
-  }
-
   FORCE_INLINE iterator begin() const {
     if (!_data) return iterator();
-    return iterator(_data->head);
+    return iterator(_data->head());
   }
 
   FORCE_INLINE iterator end() const {
@@ -63,25 +61,25 @@ class ArrayConstRef : public ArrayRefBase<const ArrayData>, public Visitable {
   }
 
   FORCE_INLINE ArrayConstRef() : base_type(0) {}
-  FORCE_INLINE ArrayConstRef(const ArrayData* data) : base_type(data) {}
+  FORCE_INLINE ArrayConstRef(const CollectionData* data) : base_type(data) {}
 
   FORCE_INLINE bool operator==(ArrayConstRef rhs) const {
     return arrayEquals(_data, rhs._data);
   }
 };
 
-class ArrayRef : public ArrayRefBase<ArrayData>, public Visitable {
-  typedef ArrayRefBase<ArrayData> base_type;
+class ArrayRef : public ArrayRefBase<CollectionData>, public Visitable {
+  typedef ArrayRefBase<CollectionData> base_type;
 
  public:
   typedef ArrayIterator iterator;
 
-  FORCE_INLINE ArrayRef() : base_type(0), _memoryPool(0) {}
-  FORCE_INLINE ArrayRef(MemoryPool* pool, ArrayData* data)
-      : base_type(data), _memoryPool(pool) {}
+  FORCE_INLINE ArrayRef() : base_type(0), _pool(0) {}
+  FORCE_INLINE ArrayRef(MemoryPool* pool, CollectionData* data)
+      : base_type(data), _pool(pool) {}
 
   operator VariantRef() {
-    return VariantRef(_memoryPool, getVariantData(_data));
+    return VariantRef(_pool, reinterpret_cast<VariantData*>(_data));
   }
 
   operator ArrayConstRef() const {
@@ -110,12 +108,12 @@ class ArrayRef : public ArrayRefBase<ArrayData>, public Visitable {
   }
 
   VariantRef add() const {
-    return VariantRef(_memoryPool, arrayAdd(_data, _memoryPool));
+    return VariantRef(_pool, arrayAdd(_data, _pool));
   }
 
   FORCE_INLINE iterator begin() const {
     if (!_data) return iterator();
-    return iterator(_memoryPool, _data->head);
+    return iterator(_pool, _data->head());
   }
 
   FORCE_INLINE iterator end() const {
@@ -153,7 +151,8 @@ class ArrayRef : public ArrayRefBase<ArrayData>, public Visitable {
 
   // Copy a ArrayRef
   FORCE_INLINE bool copyFrom(ArrayRef src) const {
-    return arrayCopy(_data, src._data, _memoryPool);
+    if (!_data || !src._data) return false;
+    return _data->copyFrom(*src._data, _pool);
   }
 
   // Exports a 1D array
@@ -191,30 +190,22 @@ class ArrayRef : public ArrayRefBase<ArrayData>, public Visitable {
 
   // Gets the value at the specified index.
   FORCE_INLINE VariantRef get(size_t index) const {
-    return VariantRef(_memoryPool, arrayGet(_data, index));
+    return VariantRef(_pool, _data ? _data->get(index) : 0);
   }
 
   // Removes element at specified position.
   FORCE_INLINE void remove(iterator it) const {
-    arrayRemove(_data, it.internal());
+    if (!_data) return;
+    _data->remove(it.internal());
   }
 
   // Removes element at specified index.
   FORCE_INLINE void remove(size_t index) const {
-    arrayRemove(_data, index);
-  }
-
-  template <typename Visitor>
-  FORCE_INLINE void accept(Visitor& visitor) const {
-    ArrayConstRef(_data).accept(visitor);
+    if (!_data) return;
+    _data->remove(index);
   }
 
  private:
-  template <typename TValueRef>
-  FORCE_INLINE bool add_impl(TValueRef value) const {
-    return add().set(value);
-  }
-
-  MemoryPool* _memoryPool;
+  MemoryPool* _pool;
 };
 }  // namespace ARDUINOJSON_NAMESPACE