Removed type erasure in containers

Summary:
Refs T196
Using QVector as this is Qt's recommended container type.

Reviewers: #swift_developers, rwinklmeier

Reviewed By: #swift_developers, rwinklmeier

Subscribers: rwinklmeier, jenkins

Tags: #swift_pilot_client

Maniphest Tasks: T196

Differential Revision: https://dev.swift-project.org/D61

src/blackmisc/sequence.h

@@ -12,34 +12,22 @@
 #ifndef BLACKMISC_SEQUENCE_H
 #define BLACKMISC_SEQUENCE_H
 
-#include "iterator.h"
 #include "containerbase.h"
 #include "propertyindex.h"
 #include "icon.h"
-#include <QScopedPointer>
+#include <QVector>
 #include <algorithm>
 #include <type_traits>
 #include <iterator>
 #include <utility>
 #include <initializer_list>
 
-// conditions matched with pop pragmas at bottom of file
-#if defined(QT_CC_CLANG)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wshorten-64-to-32"
-#elif defined(Q_CC_MSVC) && defined(Q_OS_WIN64) && defined(QT_CC_WARNINGS)
-#pragma warning(push)
-#pragma warning(disable:4244)
-#endif
-
 namespace BlackMisc
 {
 
     /*!
-     * Generic type-erased sequential container with value semantics.
+     * Generic sequential container with value semantics.
      * \tparam T the type of elements contained.
-     *
-     * Can take any suitable container class as its implementation at runtime.
      */
     template <class T>
     class CSequence :
@@ -55,231 +43,197 @@ namespace BlackMisc
         typedef const T &const_reference;
         typedef T *pointer;
         typedef const T *const_pointer;
-        typedef typename Iterators::ConstRandomAccessIterator<T> const_iterator;
-        typedef typename Iterators::RandomAccessIterator<T> iterator;
-        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-        typedef std::reverse_iterator<iterator> reverse_iterator;
+        typedef typename QVector<T>::const_iterator const_iterator;
+        typedef typename QVector<T>::iterator iterator;
+        typedef typename QVector<T>::const_reverse_iterator const_reverse_iterator;
+        typedef typename QVector<T>::reverse_iterator reverse_iterator;
         typedef ptrdiff_t difference_type;
         typedef int size_type;
         //! @}
 
         //! Default constructor.
-        CSequence() : m_pimpl(new Pimpl<QList<T>>(QList<T>())) {}
+        CSequence() {}
 
         //! Initializer list constructor.
-        CSequence(std::initializer_list<T> il) : m_pimpl(new Pimpl<QList<T>>(QList<T>(il))) {}
+        CSequence(std::initializer_list<T> il) : m_impl(il) {}
+
+        //! By QVector of type T.
+        //! @{
+        CSequence(const QVector<T> &vector) : m_impl(vector) {}
+        CSequence(QVector<T> &&vector) : m_impl(std::move(vector)) {}
+        //! @}
 
         //! By QList of type T.
-        CSequence(const QList<T> &list) : m_pimpl(new Pimpl<QList<T>>(QList<T>(list))) {}
+        CSequence(const QList<T> &list) : m_impl(list.toVector()) {}
 
         //! Copy constructor.
-        CSequence(const CSequence &other) : m_pimpl(other.pimpl() ? other.pimpl()->clone() : nullptr) {}
+        CSequence(const CSequence &other) = default;
 
         //! Move constructor.
-        CSequence(CSequence &&other) noexcept(std::is_nothrow_move_constructible<T>::value) : m_pimpl(other.m_pimpl.take()) {}
+        CSequence(CSequence &&other) = default;
 
         //! Copy assignment.
-        CSequence &operator =(const CSequence &other) { m_pimpl.reset(other.pimpl() ? other.pimpl()->clone() : nullptr); return *this; }
+        CSequence &operator =(const CSequence &other) = default;
 
         //! Move assignment.
-        CSequence &operator =(CSequence && other) noexcept(std::is_nothrow_move_assignable<T>::value) { m_pimpl.reset(other.m_pimpl.take()); return *this; }
+        CSequence &operator =(CSequence &&other) = default;
 
         //! Destructor.
         ~CSequence() = default;
 
-        //! Create a new sequence with a specific implementation type.
-        //! \tparam C Becomes the sequence's implementation type.
-        //! \param c Initial value for the sequence; default is empty, but it could contain elements if desired. The value is copied.
-        template <class C> static CSequence fromImpl(C c = C()) { return CSequence(new Pimpl<C>(std::move(c))); }
-
-        //! Change the implementation type but keep all the same elements, by moving them into the new implementation.
-        //! \tparam C Becomes the sequence's new implementation type.
-        template <class C> void changeImpl(C = C()) { auto c = fromImpl(C()); std::move(begin(), end(), std::inserter(c, c.begin())); *this = std::move(c); }
-
-        //! Like changeImpl, but uses the implementation type of another sequence.
-        //! \pre The other sequence must be initialized.
-        void useImplOf(const CSequence &other) { CSequence c(other.pimpl()->cloneEmpty()); std::move(begin(), end(), std::inserter(c, c.begin())); *this = std::move(c); }
-
         //! Returns iterator at the beginning of the sequence.
-        iterator begin() { return pimpl() ? pimpl()->begin() : iterator(); }
+        iterator begin() { return m_impl.begin(); }
 
         //! Returns const iterator at the beginning of the sequence.
-        const_iterator begin() const { return pimpl() ? pimpl()->begin() : const_iterator(); }
+        const_iterator begin() const { return m_impl.begin(); }
 
         //! Returns const iterator at the beginning of the sequence.
-        const_iterator cbegin() const { return pimpl() ? pimpl()->cbegin() : const_iterator(); }
+        const_iterator cbegin() const { return m_impl.cbegin(); }
 
         //! Returns iterator one past the end of the sequence.
-        iterator end() { return pimpl() ? pimpl()->end() : iterator(); }
+        iterator end() { return m_impl.end(); }
 
         //! Returns const iterator one past the end of the sequence.
-        const_iterator end() const { return pimpl() ? pimpl()->end() : const_iterator(); }
+        const_iterator end() const { return m_impl.end(); }
 
         //! Returns const iterator one past the end of the sequence.
-        const_iterator cend() const { return pimpl() ? pimpl()->cend() : const_iterator(); }
+        const_iterator cend() const { return m_impl.cend(); }
 
         //! Returns iterator at the beginning of the reversed sequence.
-        reverse_iterator rbegin() { return reverse_iterator(end()); }
+        reverse_iterator rbegin() { return m_impl.rbegin(); }
 
         //! Returns const iterator at the beginning of the reversed sequence.
-        const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+        const_reverse_iterator rbegin() const { return m_impl.rbegin(); }
 
         //! Returns const iterator at the beginning of the reversed sequence.
-        const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }
+        const_reverse_iterator crbegin() const { return m_impl.crbegin(); }
 
         //! Returns iterator at the end of the reversed sequence.
-        reverse_iterator rend() { return reverse_iterator(begin()); }
+        reverse_iterator rend() { return m_impl.rend(); }
 
         //! Returns const iterator at the end of the reversed sequence.
-        const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+        const_reverse_iterator rend() const { return m_impl.rend(); }
 
         //! Returns const iterator at the end of the reversed sequence.
-        const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); }
+        const_reverse_iterator crend() const { return m_impl.crend(); }
 
         //! Swap this sequence with another.
-        void swap(CSequence &other) noexcept { m_pimpl.swap(other.m_pimpl); }
+        void swap(CSequence &other) noexcept { m_impl.swap(other.m_impl); }
 
         //! Access an element by its index.
-        //! \pre The sequence must be initialized and the index in bounds.
-        reference operator [](size_type index) { Q_ASSERT(pimpl()); return pimpl()->operator [](index); }
+        reference operator [](size_type index) { Q_ASSERT(index >= 0 && index < m_impl.size()); return m_impl[index]; }
 
         //! Access an element by its index.
-        //! \pre The sequence must be initialized and the index in bounds.
-        const_reference operator [](size_type index) const { Q_ASSERT(pimpl()); return pimpl()->operator [](index); }
+        const_reference operator [](size_type index) const { Q_ASSERT(index >= 0 && index < m_impl.size()); return m_impl[index]; }
 
         //! Access the first element.
-        //! \pre The sequence must not be empty.
-        reference front() { Q_ASSERT(!empty()); return pimpl()->front(); }
+        reference front() { Q_ASSERT(!empty()); return m_impl.front(); }
 
         //! Access the first element.
-        //! \pre The sequence must not be empty.
-        const_reference front() const { Q_ASSERT(!empty()); return pimpl()->front(); }
+        const_reference front() const { Q_ASSERT(!empty()); return m_impl.front(); }
 
         //! Access the first element, or a default-initialized value if the sequence is empty.
-        const_reference frontOrDefault() const { static const value_type def {}; return empty() ? def : front(); }
+        const_reference frontOrDefault() const { static const value_type def {}; return empty() ? def : m_impl.front(); }
 
         //! Access the first element, or a default-initialized value if the sequence is empty.
-        value_type frontOrDefault(value_type def) const { return empty() ? def : front(); }
+        value_type frontOrDefault(value_type def) const { return empty() ? def : m_impl.front(); }
 
         //! Access the last element.
-        //! \pre The sequence must not be empty.
-        reference back() { Q_ASSERT(!empty()); return pimpl()->back(); }
+        reference back() { Q_ASSERT(!empty()); return m_impl.back(); }
 
         //! Access the last element.
-        //! \pre The sequence must not be empty.
-        const_reference back() const { Q_ASSERT(!empty()); return pimpl()->back(); }
+        const_reference back() const { Q_ASSERT(!empty()); return m_impl.back(); }
 
         //! Access the last element, or a default value if the sequence is empty.
-        const_reference backOrDefault() const { static const value_type def {}; return empty() ? def : back(); }
+        const_reference backOrDefault() const { static const value_type def {}; return empty() ? def : m_impl.back(); }
 
         //! Access the last element, or a default value if the sequence is empty.
-        value_type backOrDefault(value_type def) const { return empty() ? def : back(); }
+        value_type backOrDefault(value_type def) const { return empty() ? def : m_impl.back(); }
 
         //! Returns number of elements in the sequence.
-        size_type size() const { return pimpl() ? pimpl()->size() : 0; }
+        size_type size() const { return m_impl.size(); }
 
         //! Returns true if the sequence is empty.
-        bool empty() const { return pimpl() ? pimpl()->empty() : true; }
+        bool empty() const { return m_impl.isEmpty(); }
 
         //! Synonym for empty.
         bool isEmpty() const { return empty(); }
 
         //! Removes all elements in the sequence.
-        void clear() { if (pimpl()) pimpl()->clear(); }
+        void clear() { m_impl.clear(); }
 
         //! Changes the size of the sequence, if it is bigger than the given size.
         void truncate(size_type maxSize) { if (size() > maxSize) { erase(begin() + maxSize, end()); } }
 
         //! Inserts an element into the sequence.
         //! \return An iterator to the position where value was inserted.
-        //! \pre The sequence must be initialized.
-        iterator insert(iterator before, const T &value) { Q_ASSERT(pimpl()); return pimpl()->insert(before, value); }
+        iterator insert(iterator before, const T &value) { return m_impl.insert(before, value); }
 
         //! Moves an element into the sequence.
         //! \return An iterator to the position where value was inserted.
-        //! \pre The sequence must be initialized.
-        iterator insert(iterator before, T &&value) { Q_ASSERT(pimpl()); return pimpl()->insert(before, std::move(value)); }
+        iterator insert(iterator before, T &&value) { return m_impl.insert(before, std::move(value)); }
 
         //! Appends an element at the end of the sequence.
-        //! \pre The sequence must be initialized.
-        void push_back(const T &value) { Q_ASSERT(pimpl()); pimpl()->push_back(value); }
+        void push_back(const T &value) { m_impl.push_back(value); }
 
         //! Insert as first element.
-        //! \pre The sequence must be initialized.
         void push_front(const T &value) { insert(begin(), value); }
 
         //! Move-appends an element at the end of the sequence.
-        //! \pre The sequence must be initialized.
-        void push_back(T &&value) { Q_ASSERT(pimpl()); pimpl()->push_back(std::move(value)); }
+        void push_back(T &&value) { m_impl.push_back(std::move(value)); }
 
         //! Move-insert as first element.
-        //! \pre The sequence must be initialized.
         void push_front(T &&value) { insert(begin(), std::move(value)); }
 
         //! Appends all elements from another sequence at the end of this sequence.
-        //! \pre This sequence must be initialized.
         void push_back(const CSequence &other) { std::copy(other.begin(), other.end(), std::back_inserter(*this)); }
 
         //! Appends all elements from another sequence at the end of this sequence.
         //! This version moves elements instead of copying.
-        //! \pre This sequence must be initialized.
         void push_back(CSequence &&other) { std::move(other.begin(), other.end(), std::back_inserter(*this)); }
 
         //! Appends all elements from a range at the end of this sequence.
-        //! \pre This sequence must be initialized.
         template <typename I>
         void push_back(const CRange<I> &range) { std::copy(range.begin(), range.end(), std::back_inserter(*this)); }
 
         //! Synonym for push_back.
-        //! \pre The sequence must be initialized.
         void insert(const T &value) { push_back(value); }
 
         //! Synonym for push_back.
-        //! \pre The sequence must be initialized.
         void insert(T &&value) { push_back(std::move(value)); }
 
         //! Synonym for push_back.
-        //! \pre The sequence must be initialized.
         void insert(const CSequence &other) { push_back(other); }
 
         //! Synonym for push_back.
-        //! \pre The sequence must be initialized.
         void insert(CSequence &&other) { push_back(std::move(other)); }
 
         //! Synonym for push_back.
-        //! \pre This sequence must be initialized.
         template <typename I>
         void insert(const CRange<I> &range) { std::copy(range.begin(), range.end(), std::back_inserter(*this)); }
 
         //! Concatenates two sequences and returns the result.
-        //! \pre This sequence must be initialized.
         CSequence join(const CSequence &other) const { CSequence copy(*this); copy.push_back(other); return copy; }
 
         //! Concatenates a sequence and a range and returns the result.
-        //! \pre This sequence must be initialized.
         template <typename I>
         CSequence join(const CRange<I> &range) const { CSequence copy(*this); copy.push_back(range); return copy; }
 
         //! Removes an element at the end of the sequence.
-        //! \pre The sequence must contain at least one element.
-        void pop_back() { Q_ASSERT(!empty()); pimpl()->pop_back(); }
+        void pop_back() { Q_ASSERT(!empty()); m_impl.pop_back(); }
 
         //! Removes an element at the end of the sequence.
-        //! \pre The sequence must contain at least one element.
-        void pop_front() { erase(begin()); }
+        void pop_front() { Q_ASSERT(!empty()); erase(begin()); }
 
         //! Remove the element pointed to by the given iterator.
         //! \return An iterator to the position of the next element after the one removed.
-        //! \pre The sequence must be initialized.
-        iterator erase(iterator pos) { Q_ASSERT(pimpl()); return pimpl()->erase(pos); }
+        iterator erase(iterator pos) { return m_impl.erase(pos); }
 
         //! Remove the range of elements between two iterators.
         //! \return An iterator to the position of the next element after the one removed.
-        //! \pre The sequence must be initialized.
-        iterator erase(iterator it1, iterator it2) { Q_ASSERT(pimpl()); return pimpl()->erase(it1, it2); }
+        iterator erase(iterator it1, iterator it2) { return m_impl.erase(it1, it2); }
 
         //! Return an iterator to the first element equal to the given object, or the end iterator if not found. O(n).
-        //! \warning Take care that the returned non-const iterator is not compared with a const iterator.
         iterator find(const T &object) { return std::find(begin(), end(), object); }
 
         //! Return an iterator to the first element equal to the given object, or the end iterator if not found. O(n).
@@ -311,7 +265,6 @@ namespace BlackMisc
         }
 
         //! Remove all elements equal to the given object, if it is contained.
-        //! \pre The sequence must be initialized.
         //! \return The number of elements removed.
         int remove(const T &object)
         {
@@ -322,7 +275,6 @@ namespace BlackMisc
         }
 
         //! Remove elements for which a given predicate returns true.
-        //! \pre The sequence must be initialized.
         //! \return The number of elements removed.
         template <class Predicate>
         int removeIf(Predicate p)
@@ -342,7 +294,6 @@ namespace BlackMisc
         }
 
         //! Remove all elements if they are in other
-        //! \pre The sequence must be initialized.
         //! \return The number of elements removed.
         int removeIfIn(const CSequence &other)
         {
@@ -386,7 +337,6 @@ namespace BlackMisc
         }
 
         //! Replace elements for which a given predicate returns true. If there is no match, push the new element on the end.
-        //! \pre The sequence must be initialized.
         template <class Predicate>
         void replaceOrAdd(Predicate p, const T &replacement)
         {
@@ -395,7 +345,6 @@ namespace BlackMisc
         }
 
         //! Replace elements matching the given element. If there is no match, push the new element on the end.
-        //! \pre The sequence must be initialized.
         void replaceOrAdd(const T &original, const T &replacement)
         {
             if (this->contains(original)) { replace(original, replacement); }
@@ -406,7 +355,6 @@ namespace BlackMisc
         //! \param key1 A pointer to a member function of T.
         //! \param value1 Will be compared to the return value of key1.
         //! \param replacement All matching elements will be replaced by copies of this one, or a copy will be added.
-        //! \pre The sequence must be initialized.
         template <class K1, class V1>
         void replaceOrAdd(K1 key1, V1 value1, const T &replacement)
         {
@@ -537,110 +485,25 @@ namespace BlackMisc
         }
 
         //! Equals operator.
-        friend bool operator ==(const CSequence &a, const CSequence &b)
-        {
-            if (a.size() != b.size()) { return false; }
-            return std::equal(a.begin(), a.end(), b.begin());
-        }
+        friend bool operator ==(const CSequence &a, const CSequence &b) { return a.m_impl == b.m_impl; }
 
         //! Not equals operator.
-        friend bool operator !=(const CSequence &a, const CSequence &b) { return !(a == b); }
+        friend bool operator !=(const CSequence &a, const CSequence &b) { return a.m_impl != b.m_impl; }
 
         //! Less than operator.
-        friend bool operator <(const CSequence &a, const CSequence &b)
-        {
-            return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
-        }
+        friend bool operator <(const CSequence &a, const CSequence &b) { return a.m_impl < b.m_impl; }
 
         //! Greater than operator.
-        friend bool operator >(const CSequence &a, const CSequence &b) { return b < a; }
+        friend bool operator >(const CSequence &a, const CSequence &b) { return a.m_impl > b.m_impl; }
 
         //! Less or equal than operator.
-        friend bool operator <=(const CSequence &a, const CSequence &b) { return !(b < a); }
+        friend bool operator <=(const CSequence &a, const CSequence &b) { return a.m_impl <= b.m_impl; }
 
         //! Greater or equal operator.
-        friend bool operator >=(const CSequence &a, const CSequence &b) { return !(a < b); }
-
-        //! Return an opaque pointer to the implementation container.
-        //! \details Can be useful in unusual debugging situations.
-        //! \warning Not for general use.
-        void *getImpl() { return pimpl() ? pimpl()->impl() : nullptr; }
+        friend bool operator >=(const CSequence &a, const CSequence &b) { return a.m_impl >= b.m_impl; }
 
     private:
-        class PimplBase
-        {
-        public:
-            PimplBase() {}
-            PimplBase(const PimplBase &) = default;
-            PimplBase &operator =(const PimplBase &) = delete;
-            virtual ~PimplBase() {}
-            virtual PimplBase *clone() const = 0;
-            virtual PimplBase *cloneEmpty() const = 0;
-            virtual iterator begin() = 0;
-            virtual const_iterator begin() const = 0;
-            virtual const_iterator cbegin() const = 0;
-            virtual iterator end() = 0;
-            virtual const_iterator end() const = 0;
-            virtual const_iterator cend() const = 0;
-            virtual reference operator [](size_type index) = 0;
-            virtual const_reference operator [](size_type index) const = 0;
-            virtual reference front() = 0;
-            virtual const_reference front() const = 0;
-            virtual reference back() = 0;
-            virtual const_reference back() const = 0;
-            virtual size_type size() const = 0;
-            virtual bool empty() const = 0;
-            virtual void clear() = 0;
-            virtual iterator insert(iterator pos, const T &value) = 0;
-            virtual void push_back(const T &value) = 0;
-            virtual void push_back(T &&value) = 0;
-            virtual void pop_back() = 0;
-            virtual iterator erase(iterator pos) = 0;
-            virtual iterator erase(iterator it1, iterator it2) = 0;
-            virtual void *impl() = 0;
-        };
-
-        template <class C> class Pimpl : public PimplBase
-        {
-        public:
-            static_assert(std::is_same<T, typename C::value_type>::value, "CSequence must be initialized from a container with the same value_type.");
-            Pimpl(C &&c) : m_impl(std::move(c)) {}
-            PimplBase *clone() const override { return new Pimpl(*this); }
-            PimplBase *cloneEmpty() const override { return new Pimpl(C()); }
-            iterator begin() override { return iterator::fromImpl(m_impl.begin()); }
-            const_iterator begin() const override { return const_iterator::fromImpl(m_impl.cbegin()); }
-            const_iterator cbegin() const override { return const_iterator::fromImpl(m_impl.cbegin()); }
-            iterator end() override { return iterator::fromImpl(m_impl.end()); }
-            const_iterator end() const override { return const_iterator::fromImpl(m_impl.cend()); }
-            const_iterator cend() const override { return const_iterator::fromImpl(m_impl.cend()); }
-            reference operator [](size_type index) override { return m_impl[index]; }
-            const_reference operator [](size_type index) const override { return m_impl[index]; }
-            reference front() override { return m_impl.front(); }
-            const_reference front() const override { return m_impl.front(); }
-            reference back() override { return m_impl.back(); }
-            const_reference back() const override { return m_impl.back(); }
-            size_type size() const override { return static_cast<size_type>(m_impl.size()); }
-            bool empty() const override { return m_impl.empty(); }
-            void clear() override { m_impl.clear(); }
-            iterator insert(iterator pos, const T &value) override { return iterator::fromImpl(m_impl.insert(pos.template getImpl<const typename C::iterator>(), value)); }
-            void push_back(const T &value) override { m_impl.push_back(value); }
-            void push_back(T &&value) override { m_impl.push_back(std::move(value)); }
-            void pop_back() override { m_impl.pop_back(); }
-            iterator erase(iterator pos) override { return iterator::fromImpl(m_impl.erase(pos.template getImpl<const typename C::iterator>())); }
-            iterator erase(iterator it1, iterator it2) override { return iterator::fromImpl(m_impl.erase(it1.template getImpl<const typename C::iterator>(), it2.template getImpl<const typename C::iterator>())); }
-            void *impl() override { return &m_impl; }
-        private:
-            C m_impl;
-        };
-
-        using PimplPtr = QScopedPointer<PimplBase>;
-        PimplPtr m_pimpl;
-
-        explicit CSequence(PimplBase *pimpl) : m_pimpl(pimpl) {} // private ctor used by fromImpl()
-
-        // using these methods to access m_pimpl.data() eases the cognitive burden of correctly forwarding const
-        PimplBase *pimpl() { return m_pimpl.data(); }
-        const PimplBase *pimpl() const { return m_pimpl.data(); }
+        QVector<T> m_impl;
     };
 
 } //namespace BlackMisc
@@ -651,11 +514,4 @@ Q_DECLARE_METATYPE(BlackMisc::CSequence<qlonglong>)
 Q_DECLARE_METATYPE(BlackMisc::CSequence<qulonglong>)
 Q_DECLARE_METATYPE(BlackMisc::CSequence<double>)
 
-// conditions matched with pop pragmas at bottom of file
-#if defined(QT_CC_CLANG)
-#pragma clang diagnostic pop
-#elif defined(Q_CC_MSVC) && defined(Q_OS_WIN64) && defined(QT_CC_WARNINGS)
-#pragma warning(pop)
-#endif
-
 #endif //BLACKMISC_SEQUENCE_H