collection.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_COLLECTION_H
#define SWIFT_MISC_COLLECTION_H
 
#include <algorithm>
#include <initializer_list>
#include <iterator>
#include <type_traits>
#include <typeindex>
#include <utility>
 
#include <QMap>
 
#include "misc/containerbase.h"
#include "misc/mixin/mixindatastream.h"
#include "misc/mixin/mixinicon.h"

#define SWIFT_TEMPLATE_COLLECTION_MIXINS(NS, T, Set, Extern)                                                           \
    namespace NS                                                                                                       \
    {                                                                                                                  \
        class Set;                                                                                                     \
    }                                                                                                                  \
    namespace swift::misc::private_ns                                                                                  \
    {                                                                                                                  \
        Extern template struct CValueObjectMetaInfo<NS::Set>;                                                          \
        Extern template struct CValueObjectMetaInfo<CCollection<NS::T>>;                                               \
        Extern template struct MetaTypeHelper<NS::Set>;                                                                \
        Extern template struct MetaTypeHelper<CCollection<NS::T>>;                                                     \
    }                                                                                                                  \
    namespace swift::misc::mixin                                                                                       \
    {                                                                                                                  \
        Extern template class MetaType<NS::Set>;                                                                       \
        Extern template class MetaType<CCollection<NS::T>>;                                                            \
        Extern template class DBusOperators<CCollection<NS::T>>;                                                       \
        Extern template class JsonOperators<CCollection<NS::T>>;                                                       \
        Extern template class String<CCollection<NS::T>>;                                                              \
        Extern template class DataStreamOperators<CCollection<NS::T>>;                                                 \
        Extern template class Icon<CCollection<NS::T>>;                                                                \
    }


#if defined(Q_OS_WIN) && defined(Q_CC_GNU)
#    define SWIFT_DECLARE_COLLECTION_MIXINS(Namespace, T, Set)
#    define SWIFT_DEFINE_COLLECTION_MIXINS(Namespace, T, Set)
#else
#    define SWIFT_DECLARE_COLLECTION_MIXINS(Namespace, T, Set)                                                         \
        SWIFT_TEMPLATE_COLLECTION_MIXINS(Namespace, T, Set, extern)
#    define SWIFT_DEFINE_COLLECTION_MIXINS(Namespace, T, Set) SWIFT_TEMPLATE_COLLECTION_MIXINS(Namespace, T, Set, )
#endif
 
namespace swift::misc
{

    template <class T>
    class QOrderedSet : public QMap<T, T>
    {
    public:
        using value_type = T;

        typename QMap<T, T>::iterator insert(const T &value) { return QMap<T, T>::insert(value, value); }

        QOrderedSet() = default;

        QOrderedSet(std::initializer_list<T> il)
        {
            for (const auto &v : il)
            {
                insert(v);
            }
        }

        QOrderedSet(const QList<T> &list)
        {
            for (const auto &v : list)
            {
                insert(v);
            }
        }
    };

    template <class T>
    class CCollection :
        public CContainerBase<CCollection<T>>,
        public mixin::DataStreamOperators<CCollection<T>>,
        public mixin::Icon<CCollection<T>>
    {
    public:
        using key_type = T;

        using value_type = T;

        using reference = T &;

        using const_reference = const T &;

        using pointer = T *;

        using const_pointer = const T *;

        using const_iterator = typename QOrderedSet<T>::const_iterator;

        using iterator = const_iterator; // can't modify elements in-place

        using difference_type = ptrdiff_t;

        using size_type = int;

        CCollection() = default;

        CCollection(std::initializer_list<T> il) : m_impl(il) {}

        CCollection(const CCollection &other) = default;

        CCollection(const QList<T> &list) : m_impl(list) {}

        CCollection(CCollection &&other) = default;

        CCollection &operator=(const CCollection &other) = default;

        CCollection &operator=(CCollection &&other) = default;

        ~CCollection() = default;

        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(); }

        void swap(CCollection &other) noexcept { m_impl.swap(other.m_impl); }

        size_type size() const { return m_impl.size(); }

        bool empty() const { return m_impl.isEmpty(); }

        bool isEmpty() const { return empty(); }

        void clear() { m_impl.clear(); }

        iterator insert(const_iterator hint, const T &value)
        {
            Q_UNUSED(hint);
            return insert(value);
        }

        iterator insert(const_iterator hint, T &&value)
        {
            Q_UNUSED(hint);
            return insert(std::move(value));
        }

        iterator insert(const T &value) { return m_impl.insert(value); }

        iterator insert(T &&value) { return m_impl.insert(std::move(value)); }

        void insert(const CCollection &other) { std::copy(other.begin(), other.end(), std::inserter(*this, begin())); }

        void insert(CCollection &&other) { std::move(other.begin(), other.end(), std::inserter(*this, begin())); }

        template <typename I>
        void insert(const CRange<I> &range)
        {
            std::copy(range.begin(), range.end(), std::back_inserter(*this));
        }

        iterator push_back(const T &value) { return insert(value); }

        iterator push_back(T &&value) { return insert(std::move(value)); }

        void push_back(const CCollection &other) { insert(other); }

        void push_back(CCollection &&other) { insert(std::move(other)); }

        template <typename I>
        void push_back(const CRange<I> &range)
        {
            std::copy(range.begin(), range.end(), std::back_inserter(*this));
        }

        template <class C>
        CCollection makeUnion(const C &other) const
        {
            CCollection result;
            std::set_union(begin(), end(), other.begin(), other.end(), std::inserter(result, result.begin()));
            return result;
        }

        template <class C>
        CCollection intersection(const C &other) const
        {
            CCollection result;
            std::set_intersection(begin(), end(), other.begin(), other.end(), std::inserter(result, result.begin()));
            return result;
        }

        template <class C>
        CCollection difference(const C &other) const
        {
            CCollection result;
            std::set_difference(begin(), end(), other.begin(), other.end(), std::inserter(result, result.begin()));
            return result;
        }

        iterator erase(iterator pos) { return m_impl.erase(pos); }

        iterator erase(iterator it1, iterator it2)
        {
            while (it1 != it2)
            {
                it1 = erase(it1);
            }
            return it1;
        }

        iterator find(const T &value) { return m_impl.find(value); }

        const_iterator find(const T &value) const { return m_impl.find(value); }

        void remove(const T &object)
        {
            auto it = find(object);
            if (it != end())
            {
                erase(it);
            }
        }

        void remove(const CCollection &other) { *this = CCollection(*this).difference(other); }

        template <class Predicate>
        int removeIf(Predicate p)
        {
            int count = 0;
            for (auto it = begin(); it != end();)
            {
                if (p(*it))
                {
                    it = erase(it);
                    count++;
                }
                else
                {
                    ++it;
                }
            }
            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 CCollection::CContainerBase::removeIf(k0, v0, keysValues...);
        }

        QList<T> toQList() const { return this->to(QList<T>()); }

        void detach() { m_impl.detach(); }

        friend bool operator==(const CCollection &a, const CCollection &b) { return a.m_impl == b.m_impl; }

        friend bool operator!=(const CCollection &a, const CCollection &b) { return a.m_impl != b.m_impl; }

        void marshalToDataStream(QDataStream &stream) const { stream << m_impl; }

        void unmarshalFromDataStream(QDataStream &stream) { stream >> m_impl; }
 
    private:
        QOrderedSet<T> m_impl;
    };
 
} // namespace swift::misc
 
Q_DECLARE_METATYPE(swift::misc::CCollection<int>)
Q_DECLARE_METATYPE(swift::misc::CCollection<uint>)
Q_DECLARE_METATYPE(swift::misc::CCollection<qlonglong>)
Q_DECLARE_METATYPE(swift::misc::CCollection<qulonglong>)
// CCollection<double> not instantiated due to it being a dumb idea because of rounding issues
 
#endif // SWIFT_MISC_COLLECTION_H