Merge pull request #576 from scratchcpp/refactor_list

Refactor List class

Author: adazem009

Doxyfile

@@ -958,7 +958,9 @@ RECURSIVE              = YES
 # run.
 
 EXCLUDE                = docs/theme \
-                         include/scratchcpp/spimpl.h
+                         include/scratchcpp/spimpl.h \
+                         include/scratchcpp/signal.h \
+                         include/scratchcpp/veque.h
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded

include/scratchcpp/list.h

@@ -3,7 +3,7 @@
 #pragma once
 
 #include <string>
-#include <deque>
+#include <scratchcpp/veque.h>
 
 #include "value.h"
 #include "entity.h"
@@ -15,15 +15,19 @@ class Target;
 class Monitor;
 class ListPrivate;
 
-/*! \brief The List class represents a Scratch list. */
-class LIBSCRATCHCPP_EXPORT List
-    : public std::deque<Value>
-    , public Entity
+/*!
+ * \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:
         List(const std::string &id, const std::string &name);
         List(const List &) = delete;
 
+        ~List();
+
         const std::string &name();
         void setName(const std::string &name);
 
@@ -33,24 +37,197 @@ class LIBSCRATCHCPP_EXPORT List
         Monitor *monitor() const;
         void setMonitor(Monitor *monitor);
 
-        long indexOf(const Value &value) const;
-        bool contains(const Value &value) const;
+        /*! Returns the list size. */
+        inline size_t size() const { return m_size; }
+
+        /*! Returns true if the list is 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_size; i++) {
+                if (value_equals(&m_dataPtr->operator[](i), &value))
+                    return i;
+            }
+
+            return -1;
+        }
+
+        /*! Returns the index of the given item. */
+        inline size_t indexOf(const Value &value) const { return indexOf(value.data()); }
+
+        /*! Returns true if the list contains the given item. */
+        inline bool contains(const ValueData &value) const { return (indexOf(value) != -1); }
+
+        /*! Returns true if the list contains the given item. */
+        inline bool contains(const Value &value) const { return contains(value.data()); }
+
+        /*! Clears the list. */
+        inline void clear()
+        {
+            // Keep at least 200,000 items allocated if the list has more
+            constexpr size_t limit = 200000;
+            m_size = 0;
+
+            if (m_dataPtr->size() > limit)
+                reserve(limit);
+        }
+
+        /*! 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) { value_assign_copy(&appendEmpty(), &value); }
+
+        /*! Appends an item. */
+        inline void append(const Value &value) { append(value.data()); }
 
         /*! Removes the item at index. */
-        void removeAt(int index) { erase(begin() + index); }
+        inline void removeAt(size_t index)
+        {
+            assert(index >= 0 && index < size());
+            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_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);
+        }
 
         /*! Inserts an item at index. */
-        void insert(int index, const Value &value) { std::deque<Value>::insert(begin() + index, value); }
+        inline void insert(size_t index, const Value &value) { insert(index, value.data()); }
 
         /*! Replaces the item at index. */
-        void replace(int index, const Value &value) { at(index) = value; }
+        inline void replace(size_t index, const ValueData &value)
+        {
+            assert(index >= 0 && index < size());
+            value_assign_copy(&m_dataPtr->operator[](index), &value);
+        }
 
-        std::string toString() const;
+        /*! Replaces the item at index. */
+        inline void replace(size_t index, const Value &value) { replace(index, value.data()); }
+
+        inline ValueData &operator[](size_t index)
+        {
+            assert(index >= 0 && index < size());
+            return m_dataPtr->operator[](index);
+        }
+
+        /*! Joins the list items with spaces or without any separator if there are only digits and stores the result in dst. */
+        inline void toString(std::string &dst) const
+        {
+            dst.clear();
+            veque::veque<std::string> strings;
+            strings.reserve(m_size);
+            bool digits = true;
+            size_t i;
+
+            for (i = 0; i < m_size; i++) {
+                const ValueData *item = &m_dataPtr->operator[](i);
+                strings.push_back(std::string());
+                value_toString(item, &strings.back());
+
+                if (value_isValidNumber(item) && !strings.back().empty()) {
+                    double doubleNum = value_toDouble(item);
+                    long num = value_toLong(item);
+
+                    if (doubleNum != num) {
+                        digits = false;
+                        break;
+                    }
+
+                    if (num < 0 || num >= 10) {
+                        digits = false;
+                        break;
+                    }
+                } else {
+                    digits = false;
+                    break;
+                }
+            }
+
+            std::string s;
+
+            if (digits) {
+                for (i = 0; i < strings.size(); i++)
+                    dst.append(strings[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_size)
+                        dst.push_back(' ');
+                }
+
+                for (; i < m_size; i++) {
+                    value_toString(&m_dataPtr->operator[](i), &s);
+                    dst.append(s);
+
+                    if (i + 1 < m_size)
+                        dst.push_back(' ');
+                }
+            }
+        }
+
+        /*! Same as the other method, but returns the result directly. */
+        inline std::string toString() const
+        {
+            std::string ret;
+            toString(ret);
+            return ret;
+        }
 
         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

include/scratchcpp/value.h

@@ -84,6 +84,13 @@ class LIBSCRATCHCPP_EXPORT Value
             value_assign_special(&m_data, specialValue);
         }
 
+        /*! Constructs value from ValueData. */
+        Value(const ValueData &v)
+        {
+            value_init(&m_data);
+            value_assign_copy(&m_data, &v);
+        }
+
         Value(const Value &v)
         {
             value_init(&m_data);
@@ -92,6 +99,18 @@ class LIBSCRATCHCPP_EXPORT Value
 
         ~Value() { value_free(&m_data); }
 
+        /*!
+         * Returns a read-only reference to the data.
+         * \note Valid until the Value object is destroyed.
+         */
+        const ValueData &data() const { return m_data; };
+
+        /*!
+         * Returns a read/write reference to the data.
+         * \note Valid until the Value object is destroyed.
+         */
+        ValueData &data() { return m_data; }
+
         /*! Returns the type of the value. */
         ValueType type() const { return m_data.type; }
 
@@ -204,6 +223,12 @@ class LIBSCRATCHCPP_EXPORT Value
             return *this;
         }
 
+        const Value &operator=(const ValueData &v)
+        {
+            value_assign_copy(&m_data, &v);
+            return *this;
+        }
+
         const Value &operator=(const Value &v)
         {
             value_assign_copy(&m_data, &v.m_data);