sequence.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_SEQUENCE_H
#define SWIFT_MISC_SEQUENCE_H
 
#include <algorithm>
#include <functional>
#include <initializer_list>
#include <iterator>
#include <type_traits>
#include <utility>
 
#include <QVector>
 
#include "misc/containerbase.h"
#include "misc/mixin/mixindatastream.h"
#include "misc/mixin/mixinicon.h"
#include "misc/swiftmiscexport.h"
 
#define SWIFT_TEMPLATE_SEQUENCE_MIXINS(NS, T, List, Extern)                                                            \
    namespace NS                                                                                                       \
    {                                                                                                                  \
        class List;                                                                                                    \
    }                                                                                                                  \
    namespace swift::misc::private_ns                                                                                  \
    {                                                                                                                  \
        Extern template struct CValueObjectMetaInfo<NS::List>;                                                         \
        Extern template struct CValueObjectMetaInfo<CSequence<NS::T>>;                                                 \
        Extern template struct MetaTypeHelper<NS::List>;                                                               \
        Extern template struct MetaTypeHelper<CSequence<NS::T>>;                                                       \
    }                                                                                                                  \
    namespace swift::misc::mixin                                                                                       \
    {                                                                                                                  \
        Extern template class MetaType<NS::List>;                                                                      \
        Extern template class MetaType<CSequence<NS::T>>;                                                              \
        Extern template class DBusOperators<CSequence<NS::T>>;                                                         \
        Extern template class JsonOperators<CSequence<NS::T>>;                                                         \
        Extern template class String<CSequence<NS::T>>;                                                                \
        Extern template class DataStreamOperators<CSequence<NS::T>>;                                                   \
        Extern template class Icon<CSequence<NS::T>>;                                                                  \
    }
 
#if defined(Q_OS_WIN) && defined(Q_CC_GNU)
#    define SWIFT_DECLARE_SEQUENCE_MIXINS(Namespace, T, List)
#    define SWIFT_DEFINE_SEQUENCE_MIXINS(Namespace, T, List)
#else
#    define SWIFT_DECLARE_SEQUENCE_MIXINS(Namespace, T, List) SWIFT_TEMPLATE_SEQUENCE_MIXINS(Namespace, T, List, extern)
#    define SWIFT_DEFINE_SEQUENCE_MIXINS(Namespace, T, List) SWIFT_TEMPLATE_SEQUENCE_MIXINS(Namespace, T, List, )
#endif
 
namespace swift::misc
{
    namespace private_ns
    {
        SWIFT_MISC_EXPORT SWIFT_NO_INLINE QVector<int> findIndices(int size, const std::function<bool(int)> &predicate);
 
        SWIFT_MISC_EXPORT SWIFT_NO_INLINE QVector<int> sortIndices(int size, const std::function<bool(int, int)> &cmp);
    } // namespace private_ns
 
    template <class T>
    class CSequence :
        public CContainerBase<CSequence<T>>,
        public mixin::DataStreamOperators<CSequence<T>>,
        public mixin::Icon<CSequence<T>>
    {
    public:
        typedef T key_type;
 
        typedef T value_type;
 
        typedef T &reference;
 
        typedef const T &const_reference;
 
        typedef T *pointer;
 
        typedef const T *const_pointer;
 
        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;
 
        CSequence() = default;
 
        CSequence(std::initializer_list<T> il) : m_impl(il) {}
 
        CSequence(QList<T> &&list) : m_impl(std::move(list)) {}
 
        CSequence(const QList<T> &list) : m_impl(list) {}
 
        template <typename It>
        CSequence(It first, It last) : m_impl(first, last)
        {}
 
        CSequence(const CSequence &other) = default;
 
        CSequence(CSequence &&other) = default;
 
        CSequence &operator=(const CSequence &other) = default;
 
        CSequence &operator=(CSequence &&other) = default;
 
        ~CSequence() = default;
 
        QVector<T> toVector() const & { return m_impl; }
 
        QVector<T> toVector() && { return std::move(m_impl); }
 
        iterator begin() { return m_impl.begin(); }
 
        const_iterator begin() const { return m_impl.begin(); }
 
        const_iterator cbegin() const { return m_impl.cbegin(); }
 
        iterator end() { return m_impl.end(); }
 
        const_iterator end() const { return m_impl.end(); }
 
        const_iterator cend() const { return m_impl.cend(); }
 
        reverse_iterator rbegin() { return m_impl.rbegin(); }
 
        const_reverse_iterator rbegin() const { return m_impl.rbegin(); }
 
        const_reverse_iterator crbegin() const { return m_impl.crbegin(); }
 
        reverse_iterator rend() { return m_impl.rend(); }
 
        const_reverse_iterator rend() const { return m_impl.rend(); }
 
        const_reverse_iterator crend() const { return m_impl.crend(); }
 
        void swap(CSequence &other) noexcept { m_impl.swap(other.m_impl); }
 
#ifdef __GNUC__
#    pragma GCC diagnostic push
#    pragma GCC diagnostic ignored "-Wstrict-overflow"
#endif
 
        reference operator[](size_type index)
        {
            Q_ASSERT(index >= 0 && index < m_impl.size());
            return m_impl[index];
        }
 
        const_reference operator[](size_type index) const
        {
            Q_ASSERT(index >= 0 && index < m_impl.size());
            return m_impl[index];
        }
 
#ifdef __GNUC__
#    pragma GCC diagnostic pop
#endif
 
        reference front()
        {
            Q_ASSERT(!empty());
            return m_impl.front();
        }
 
        const_reference front() const
        {
            Q_ASSERT(!empty());
            return m_impl.front();
        }
 
        const_reference frontOrDefault() const
        {
            static const value_type def {};
            return empty() ? def : m_impl.front();
        }
 
        value_type frontOrDefault(value_type def) const { return empty() ? def : m_impl.front(); }
 
        reference back()
        {
            Q_ASSERT(!empty());
            return m_impl.back();
        }
 
        const_reference back() const
        {
            Q_ASSERT(!empty());
            return m_impl.back();
        }
 
        const_reference backOrDefault() const
        {
            static const value_type def {};
            return empty() ? def : m_impl.back();
        }
 
        value_type backOrDefault(value_type def) const { return empty() ? def : m_impl.back(); }
 
        size_type size() const { return m_impl.size(); }
 
        int sizeInt() const { return static_cast<int>(this->size()); }
 
        QString sizeString() const { return QString::number(m_impl.size()); }
 
        bool empty() const { return m_impl.isEmpty(); }
 
        bool isEmpty() const { return empty(); }
 
        void clear() { m_impl.clear(); }
 
        void truncate(size_type maxSize)
        {
            if (size() > maxSize) { erase(begin() + maxSize, end()); }
        }
 
        iterator insert(iterator before, const T &value) { return m_impl.insert(before, value); }
 
        iterator insert(iterator before, T &&value) { return m_impl.insert(before, std::move(value)); }
 
        void push_back(const T &value) { m_impl.push_back(value); }
 
        void push_front(const T &value) { insert(begin(), value); }
 
        void push_front(const CSequence &other) { std::copy(other.begin(), other.end(), std::front_inserter(*this)); }
 
        void push_frontMaxElements(const T &value, int maxElements)
        {
            Q_ASSERT(maxElements > 1);
            if (this->size() >= (maxElements - 1)) { this->truncate(maxElements - 1); }
            this->push_front(value);
        }
 
        void push_backMaxElements(const T &value, int maxElements)
        {
            Q_ASSERT(maxElements > 1);
            while (this->size() >= (maxElements - 1)) { this->pop_front(); }
            this->push_back(value);
        }
 
        void push_back(T &&value) { m_impl.push_back(std::move(value)); }
 
        void push_front(T &&value) { insert(begin(), std::move(value)); }
 
        void push_back(const CSequence &other) { std::copy(other.begin(), other.end(), std::back_inserter(*this)); }
 
        void push_back(CSequence &&other) { std::move(other.begin(), other.end(), std::back_inserter(*this)); }
 
        template <typename I>
        void push_back(const CRange<I> &range)
        {
            std::copy(range.begin(), range.end(), std::back_inserter(*this));
        }
 
        CSequence join(const CSequence &other) const
        {
            CSequence copy(*this);
            copy.push_back(other);
            return copy;
        }
 
        template <typename I>
        CSequence join(const CRange<I> &range) const
        {
            CSequence copy(*this);
            copy.push_back(range);
            return copy;
        }
 
        void pop_back()
        {
            Q_ASSERT(!empty());
            m_impl.pop_back();
        }
 
        void pop_front()
        {
            Q_ASSERT(!empty());
            erase(begin());
        }
 
        iterator erase(iterator pos) { return m_impl.erase(pos); }
 
        iterator erase(iterator it1, iterator it2) { return m_impl.erase(it1, it2); }
 
        iterator find(const T &object) { return std::find(begin(), end(), object); }
 
        const_iterator find(const T &object) const { return std::find(cbegin(), cend(), object); }
 
        using CContainerBase<CSequence<T>>::findBy;
 
        template <class Predicate>
        CSequence findBy(Predicate p) const
        {
            QVector<T> found;
            for (int i : private_ns::findIndices(size(), [&p, this](int i) { return p((*this)[i]); }))
            {
                found.push_back((*this)[i]);
            }
            return found;
        }
 
        template <class Predicate, class VariantMap>
        int applyIf(Predicate p, const VariantMap &newValues, bool skipEqualValues = false)
        {
            int count = 0;
            for (auto &value : *this)
            {
                if (p(value) && !value.apply(newValues, skipEqualValues).isEmpty()) { count++; }
            }
            return count;
        }
 
        template <class K1, class V1, class VariantMap>
        int applyIf(K1 key1, V1 value1, const VariantMap &newValues, bool skipEqualValues = false)
        {
            return applyIf(swift::misc::predicates::MemberEqual(key1, value1), newValues, skipEqualValues);
        }
 
        int remove(const T &object)
        {
            const auto newEnd = std::remove(begin(), end(), object);
            const auto count = std::distance(newEnd, end());
            erase(newEnd, end());
            return count;
        }
 
        template <class Predicate>
        int removeIf(Predicate p)
        {
            const auto newEnd = std::remove_if(begin(), end(), p);
            const auto count = std::distance(newEnd, end());
            erase(newEnd, end());
            return count;
        }
 
        template <class K0, class V0, class... KeysValues>
        int removeIf(K0 k0, V0 v0, KeysValues... keysValues)
        {
            // using-declaration doesn't play nicely with injected template names
            return CSequence::CContainerBase::removeIf(k0, v0, keysValues...);
        }
 
        int removeIfIn(const CSequence &other)
        {
            return removeIf([&other](const T &v) { return other.contains(v); });
        }
 
        void removeIfInSubset(const CSequence &other)
        {
            erase(swift::misc::removeIfIn(begin(), end(), other.begin(), other.end()), end());
        }
 
        int replace(const T &original, const T &replacement)
        {
            int count = 0;
            for (auto &element : *this)
            {
                if (element == original)
                {
                    element = replacement;
                    count++;
                }
            }
            return count;
        }
 
        template <class Predicate>
        int replaceIf(Predicate p, const T &replacement)
        {
            int count = 0;
            for (auto &element : *this)
            {
                if (p(element))
                {
                    element = replacement;
                    count++;
                }
            }
            return count;
        }
 
        template <class K1, class V1>
        int replaceIf(K1 key1, V1 value1, const T &replacement)
        {
            return replaceIf(swift::misc::predicates::MemberEqual(key1, value1), replacement);
        }
 
        void replaceOrAdd(const T &original, const T &replacement)
        {
            if (this->contains(original)) { replace(original, replacement); }
            else { push_back(replacement); }
        }
 
        void replaceOrAdd(const T &replacement) { this->replaceOrAdd(replacement, replacement); }
 
        void replaceOrAdd(const CSequence<T> &replacements)
        {
            for (const T &replacement : replacements) { this->replaceOrAdd(replacement, replacement); }
        }
 
        template <class K1, class V1>
        void replaceOrAdd(K1 key1, V1 value1, const T &replacement)
        {
            if (this->contains(key1, value1)) { replaceIf(key1, value1, replacement); }
            else { push_back(replacement); }
        }
 
        void reverse() { std::reverse(begin(), end()); }
 
        Q_REQUIRED_RESULT CSequence reversed() const
        {
            CSequence result = *this;
            result.reverse();
            return result;
        }
 
        template <class Predicate>
        void sort(Predicate p)
        {
            QVector<T> temp;
            temp.reserve(size());
            for (int i :
                 private_ns::sortIndices(size(), [&p, this](int a, int b) { return p((*this)[a], (*this)[b]); }))
            {
                temp.push_back(std::move((*this)[i]));
            }
            m_impl = std::move(temp);
        }
 
        template <class K1, class... Keys>
        void sortBy(K1 key1, Keys... keys)
        {
            sort(swift::misc::predicates::MemberLess(key1, keys...));
        }
 
        template <class Predicate>
        Q_REQUIRED_RESULT CSequence sorted(Predicate p) const
        {
            CSequence result = *this;
            result.sort(p);
            return result;
        }
 
        template <class K1, class... Keys>
        CSequence sortedBy(K1 key1, Keys... keys) const
        {
            return sorted(swift::misc::predicates::MemberLess(key1, keys...));
        }
 
        template <class Predicate>
        void partiallySort(size_type n, Predicate p)
        {
            std::partial_sort(begin(), begin() + std::min(n, size()), end(), p);
        }
 
        template <class K1, class... Keys>
        void partiallySortBy(size_type n, K1 key1, Keys... keys)
        {
            partiallySort(n, swift::misc::predicates::MemberLess(key1, keys...));
        }
 
        template <class Predicate>
        Q_REQUIRED_RESULT CSequence partiallySorted(size_type n, Predicate p) const
        {
            CSequence result = *this;
            result.partiallySort(n, p);
            return result;
        }
 
        template <class K1, class... Keys>
        CSequence partiallySortedBy(size_type n, K1 key1, Keys... keys) const
        {
            return partiallySorted(n, swift::misc::predicates::MemberLess(key1, keys...));
        }
 
        template <class U, class Key0, class... Keys>
        bool unorderedEqualsByKeys(const U &other, Key0 k0, Keys... keys) const
        {
            if (equalPointers(this, &other)) { return true; }
            if (size() != other.size()) { return false; }
            return sorted(k0, keys...).equalsByKeys(other.sorted(k0, keys...));
        }
 
        template <class Predicate>
        auto separate(Predicate p) const -> QMap<decltype(p(std::declval<T>())), CSequence>
        {
            QMap<decltype(p(std::declval<T>())), CSequence> result;
            auto copy = *this;
            std::stable_sort(copy.begin(), copy.end(), [p](const T &a, const T &b) { return p(a) < p(b); });
            for (auto it = copy.cbegin(); it != copy.cend();)
            {
                auto mid = std::adjacent_find(it, copy.cend(), [p](const T &a, const T &b) { return p(a) != p(b); });
                result.insert(p(*it), makeRange(it, mid));
                it = mid;
            }
            return result;
        }
 
        template <class Key>
        auto separateBy(Key k) const -> QMap<decltype(std::invoke(k, std::declval<T>())), CSequence>
        {
            return separateBy([k](const T &v) { return std::invoke(k, v); });
        }
 
        void detach() { m_impl.detach(); }
 
        friend bool operator==(const CSequence &a, const CSequence &b) { return a.m_impl == b.m_impl; }
 
        friend bool operator!=(const CSequence &a, const CSequence &b) { return a.m_impl != b.m_impl; }
 
        friend bool operator<(const CSequence &a, const CSequence &b) { return a.m_impl < b.m_impl; }
 
        friend bool operator>(const CSequence &a, const CSequence &b) { return a.m_impl > b.m_impl; }
 
        friend bool operator<=(const CSequence &a, const CSequence &b) { return a.m_impl <= b.m_impl; }
 
        friend bool operator>=(const CSequence &a, const CSequence &b) { return a.m_impl >= b.m_impl; }
 
        void marshalToDataStream(QDataStream &stream) const { stream << m_impl; }
 
        void unmarshalFromDataStream(QDataStream &stream) { stream >> m_impl; }
 
    private:
        QList<T> m_impl;
    };
} // namespace swift::misc
 
Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(swift::misc::CSequence)
 
#endif // SWIFT_MISC_SEQUENCE_H