List: Do not deallocate deleted items

Author: adazem009

include/scratchcpp/list.h

@@ -15,7 +15,11 @@ class Target;
 class Monitor;
 class ListPrivate;
 
-/*! \brief The List class represents a Scratch list. */
+/*!
+ * \brief The List class represents a Scratch list.
+ *
+ * Due to the high optimization of the methods, indices out of range will result in undefined behavior!
+ */
 class LIBSCRATCHCPP_EXPORT List : public Entity
 {
     public:
@@ -34,15 +38,15 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
         void setMonitor(Monitor *monitor);
 
         /*! Returns the list size. */
-        inline size_t size() const { return m_dataPtr->size(); }
+        inline size_t size() const { return m_size; }
 
         /*! Returns true if the list is empty. */
-        inline bool empty() const { return m_dataPtr->empty(); }
+        inline bool empty() const { return m_size == 0; }
 
         /*! Returns the index of the given item. */
         inline size_t indexOf(const ValueData &value) const
         {
-            for (size_t i = 0; i < m_dataPtr->size(); i++) {
+            for (size_t i = 0; i < m_size; i++) {
                 if (value_equals(&m_dataPtr->operator[](i), &value))
                     return i;
             }
@@ -60,47 +64,37 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
         inline bool contains(const Value &value) const { return contains(value.data()); }
 
         /*! Clears the list. */
-        inline void clear()
-        {
-            for (ValueData &v : *m_dataPtr)
-                value_free(&v);
+        inline void clear() { m_size = 0; }
 
-            m_dataPtr->clear();
+        /*! Appends an empty item and returns the reference to it. Can be used for custom initialization. */
+        inline ValueData &appendEmpty()
+        {
+            m_size++;
+            reserve(getAllocSize(m_size));
+            return m_dataPtr->operator[](m_size - 1);
         }
 
         /*! Appends an item. */
-        inline void append(const ValueData &value)
-        {
-            m_dataPtr->push_back(ValueData());
-            value_init(&m_dataPtr->back());
-            value_assign_copy(&m_dataPtr->back(), &value);
-        }
+        inline void append(const ValueData &value) { value_assign_copy(&appendEmpty(), &value); }
 
         /*! Appends an item. */
         inline void append(const Value &value) { append(value.data()); }
 
-        /*! Appends an empty item and returns the reference to it. Can be used for custom initialization. */
-        inline ValueData &appendEmpty()
-        {
-            m_dataPtr->push_back(ValueData());
-            value_init(&m_dataPtr->back());
-            return m_dataPtr->back();
-        }
-
         /*! Removes the item at index. */
         inline void removeAt(size_t index)
         {
             assert(index >= 0 && index < size());
-            value_free(&m_dataPtr->operator[](index));
-            m_dataPtr->erase(m_dataPtr->begin() + index);
+            std::rotate(m_dataPtr->begin() + index, m_dataPtr->begin() + index + 1, m_dataPtr->begin() + m_size);
+            m_size--;
         }
 
         /*! Inserts an item at index. */
         inline void insert(size_t index, const ValueData &value)
         {
             assert(index >= 0 && index <= size());
-            m_dataPtr->insert(m_dataPtr->begin() + index, ValueData());
-            value_init(&m_dataPtr->operator[](index));
+            m_size++;
+            reserve(getAllocSize(m_size));
+            std::rotate(m_dataPtr->rbegin() + m_dataPtr->size() - m_size, m_dataPtr->rbegin() + m_dataPtr->size() - m_size + 1, m_dataPtr->rend() - index);
             value_assign_copy(&m_dataPtr->operator[](index), &value);
         }
 
@@ -128,16 +122,18 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
         {
             dst.clear();
             veque::veque<std::string> strings;
-            strings.reserve(m_dataPtr->size());
+            strings.reserve(m_size);
             bool digits = true;
+            size_t i;
 
-            for (const auto &item : *m_dataPtr) {
+            for (i = 0; i < m_size; i++) {
+                const ValueData *item = &m_dataPtr->operator[](i);
                 strings.push_back(std::string());
-                value_toString(&item, &strings.back());
+                value_toString(item, &strings.back());
 
-                if (value_isValidNumber(&item) && !strings.back().empty()) {
-                    double doubleNum = value_toDouble(&item);
-                    long num = value_toLong(&item);
+                if (value_isValidNumber(item) && !strings.back().empty()) {
+                    double doubleNum = value_toDouble(item);
+                    long num = value_toLong(item);
 
                     if (doubleNum != num) {
                         digits = false;
@@ -154,30 +150,29 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
                 }
             }
 
-            size_t i;
             std::string s;
 
             if (digits) {
                 for (i = 0; i < strings.size(); i++)
                     dst.append(strings[i]);
 
-                for (; i < m_dataPtr->size(); i++) {
+                for (; i < m_size; i++) {
                     value_toString(&m_dataPtr->operator[](i), &s);
                     dst.append(s);
                 }
             } else {
                 for (i = 0; i < strings.size(); i++) {
                     dst.append(strings[i]);
 
-                    if (i + 1 < m_dataPtr->size())
+                    if (i + 1 < m_size)
                         dst.push_back(' ');
                 }
 
-                for (; i < m_dataPtr->size(); i++) {
+                for (; i < m_size; i++) {
                     value_toString(&m_dataPtr->operator[](i), &s);
                     dst.append(s);
 
-                    if (i + 1 < m_dataPtr->size())
+                    if (i + 1 < m_size)
                         dst.push_back(' ');
                 }
             }
@@ -194,8 +189,37 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
         std::shared_ptr<List> clone();
 
     private:
+        inline void reserve(size_t size)
+        {
+            assert(size >= m_size);
+
+            while (size > m_dataPtr->size()) {
+                m_dataPtr->push_back(ValueData());
+                value_init(&m_dataPtr->back());
+            }
+
+            while (size < m_dataPtr->size()) {
+                value_free(&m_dataPtr->back());
+                m_dataPtr->erase(m_dataPtr->end());
+            }
+        }
+
+        inline size_t getAllocSize(size_t x)
+        {
+            if (x == 0)
+                return 0;
+
+            size_t ret = 1;
+
+            while (ret < x)
+                ret *= 2;
+
+            return ret;
+        }
+
         spimpl::unique_impl_ptr<ListPrivate> impl;
         veque::veque<ValueData> *m_dataPtr = nullptr; // NOTE: accessing through pointer is faster! (from benchmarks)
+        size_t m_size = 0;
 };
 
 } // namespace libscratchcpp

src/scratch/list.cpp

@@ -19,6 +19,7 @@ List::List(const std::string &id, const std::string &name) :
 List::~List()
 {
     clear();
+    reserve(m_size);
 }
 
 /*! Returns the name of the list. */
@@ -61,9 +62,10 @@ void List::setMonitor(Monitor *monitor)
 std::shared_ptr<List> List::clone()
 {
     auto copy = std::make_shared<List>(id(), impl->name);
+    copy->reserve(m_size);
 
-    for (const ValueData &item : *m_dataPtr)
-        copy->append(item);
+    for (size_t i = 0; i < m_size; i++)
+        copy->append(m_dataPtr->operator[](i));
 
     return copy;
 }