dictionary.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_DICTIONARY_H
#define SWIFT_MISC_DICTIONARY_H
 
#include <algorithm>
#include <initializer_list>
#include <type_traits>
#include <utility>
 
#include <QDBusArgument>
#include <QHash>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonValue>
#include <QJsonValueRef>
#include <QMap>
#include <QString>
#include <QtGlobal>
 
#include "misc/containerbase.h"
#include "misc/iterator.h"
#include "misc/jsonexception.h"
#include "misc/mixin/mixindatastream.h"
#include "misc/mixin/mixindbus.h"
#include "misc/mixin/mixinjson.h"
#include "misc/mixin/mixinstring.h"
#include "misc/predicates.h"
#include "misc/range.h"
#include "misc/typetraits.h"
 
namespace swift::misc
{
    namespace private_ns
    {
        template <bool KeySupportsQHash /* = true */, bool KeySupportsQMap>
        struct TAssociativityTraits
        {
            template <class Key, class Value>
            using DefaultType = QHash<Key, Value>;
        };
        template <>
        struct TAssociativityTraits<false, true>
        {
            template <class Key, class Value>
            using DefaultType = QMap<Key, Value>;
        };
        template <>
        struct TAssociativityTraits<false, false>
        {
            template <class Key, class>
            struct DefaultType
            {
                static_assert(std::is_void_v<Key>, "Key does not support either QHash or QMap");
            };
        };
    } // namespace private_ns
 
    template <typename K, typename V>
    using TDefaultAssociativeType =
        typename private_ns::TAssociativityTraits<TModelsQHashKey<K>::value,
                                                  TModelsQMapKey<K>::value>::template DefaultType<K, V>;
 
    template <class Key, class Value, template <class...> class Impl = TDefaultAssociativeType>
    class CDictionary :
        public mixin::DBusOperators<CDictionary<Key, Value, Impl>>,
        public mixin::DataStreamOperators<CDictionary<Key, Value, Impl>>,
        public mixin::JsonOperators<CDictionary<Key, Value, Impl>>,
        public mixin::String<CDictionary<Key, Value, Impl>>
    {
        friend int compare(const CDictionary &a, const CDictionary &b)
        {
            if (a.m_impl.size() < b.m_impl.size()) { return -1; }
            if (a.m_impl.size() > b.m_impl.size()) { return 1; }
            return 0;
        }
 
    public:
        using impl_type = Impl<Key, Value>;
 
        typedef Key key_type;
 
        typedef Value value_type;
 
        typedef Value &reference;
 
        typedef const Value &const_reference;
 
        typedef typename Impl<Key, Value>::size_type size_type;
 
        typedef typename Impl<Key, Value>::iterator iterator;
 
        typedef typename Impl<Key, Value>::const_iterator const_iterator;
 
        template <class Predicate>
        CDictionary findKeyBy(Predicate p) const
        {
            CDictionary result = *this;
            for (auto it = result.begin(); it != result.end();)
            {
                if (!p(it.key())) { it = result.erase(it); }
                else { ++it; }
            }
            return result;
        }
 
        template <class... Pairs>
        CDictionary findKeyBy(Pairs... pairs) const
        {
            return findKeyBy(swift::misc::predicates::MemberEqual(pairs...));
        }
 
        template <class Predicate>
        CDictionary findValueBy(Predicate p) const
        {
            CDictionary result = *this;
            for (auto it = result.begin(); it != result.end();)
            {
                if (!p(it.value())) { it = result.erase(it); }
                else { ++it; }
            }
            return result;
        }
 
        template <class... Pairs>
        CDictionary findValueBy(Pairs... pairs) const
        {
            return findValueBy(swift::misc::predicates::MemberEqual(pairs...));
        }
 
        template <class Predicate>
        bool containsByKey(Predicate p) const
        {
            auto keys = m_impl.keys();
            return std::any_of(keys.cbegin(), keys.cend(), p);
        }
 
        template <class MembFunc, class ReturnValue>
        bool containsByKey(MembFunc membFunc, ReturnValue returnValue) const
        {
            return containsByKey(swift::misc::predicates::MemberEqual(membFunc, returnValue));
        }
 
        template <class Predicate>
        bool containsByValue(Predicate p) const
        {
            return std::any_of(m_impl.cbegin(), m_impl.cend(), p);
        }
 
        template <class MembFunc, class ReturnValue>
        bool containsByValue(MembFunc membFunc, ReturnValue returnValue) const
        {
            return containsByValue(swift::misc::predicates::MemberEqual(membFunc, returnValue));
        }
 
        template <class Predicate>
        void removeByKeyIf(Predicate p)
        {
            for (auto it = m_impl.begin(); it != m_impl.end();)
            {
                if (p(it.key())) { it = m_impl.erase(it); }
                else { ++it; }
            }
        }
 
        template <class Predicate>
        void removeByValueIf(Predicate p)
        {
            for (auto it = m_impl.begin(); it != m_impl.end();)
            {
                if (p(it.value())) { it = m_impl.erase(it); }
                else { ++it; }
            }
        }
 
        template <class MembFunc, class ReturnValue>
        void removeByKeyIf(MembFunc membFunc, ReturnValue returnValue)
        {
            removeByKeyIf(swift::misc::predicates::MemberEqual(membFunc, returnValue));
        }
 
        template <class MembFunc, class ReturnValue>
        void removeByValueIf(MembFunc membFunc, ReturnValue returnValue)
        {
            removeByValueIf(swift::misc::predicates::MemberEqual(membFunc, returnValue));
        }
 
        void removeDuplicates(const CDictionary &other)
        {
            for (auto it = begin(); it != end();)
            {
                auto it2 = other.find(it.key());
                if (it2 != other.end() && it.value() == it2.value()) { it = erase(it); }
                else { ++it; }
            }
        }
 
        QJsonObject toJson() const
        {
            QJsonArray array;
            QJsonObject json;
 
            for (auto it = m_impl.cbegin(); it != m_impl.cend(); ++it) { array << it.key() << it.value(); }
            json.insert("associativecontainerbase", array);
            return json;
        }
 
        void convertFromJson(const QJsonObject &json)
        {
            QJsonValue value = json.value("associativecontainerbase");
            if (value.isUndefined()) { throw CJsonException("Missing 'associativecontainerbase'"); }
            QJsonArray array = value.toArray();
            int index = 0;
            for (auto it = array.begin(); it != array.end(); ++it)
            {
                QJsonValueRef jsonKey = (*it);
                ++it;
                if (it == array.end())
                {
                    qWarning("Odd number of elements in CDictionary::convertFromJson");
                    return;
                }
                QJsonValueRef jsonValue = (*it);
                Key key;
                Value val;
                {
                    CJsonScope scope("associativecontainerbase", 2 * index);
                    Q_UNUSED(scope);
                    jsonKey >> key;
                }
                {
                    CJsonScope scope("associativecontainerbase", 2 * index++ + 1);
                    Q_UNUSED(scope);
                    jsonValue >> val;
                }
                m_impl.insert(std::move(key), std::move(val));
            }
        }
 
        CDictionary() {}
 
        CDictionary(std::initializer_list<std::pair<Key, Value>> il) : m_impl(il) {}
 
        CDictionary(const CDictionary &) = default;
 
        CDictionary(CDictionary &&other) noexcept : m_impl(std::move(other.m_impl)) {}
 
        ~CDictionary() = 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(); }
 
        auto keyBegin() const { return m_impl.keyBegin(); }
 
        auto keyEnd() const { return m_impl.keyEnd(); }
 
        auto keyValueBegin() { return m_impl.keyValueBegin(); }
 
        auto keyValueEnd() { return m_impl.keyValueEnd(); }
 
        auto keyValueBegin() const { return m_impl.keyValueBegin(); }
 
        auto constKeyValueBegin() const { return m_impl.constKeyValueBegin(); }
 
        auto keyValueEnd() const { return m_impl.keyValueEnd(); }
 
        auto constKeyValueEnd() const { return m_impl.constKeyValueEnd(); }
 
        void clear() { m_impl.clear(); }
 
        const_iterator constBegin() const { return m_impl.constBegin(); }
 
        const_iterator constEnd() const { return m_impl.constEnd(); }
 
        const_iterator constFind(const Key &key) const { return m_impl.constFind(key); }
 
        const_iterator find(const Key &key) const { return m_impl.find(key); }
 
        iterator find(const Key &key) { return m_impl.find(key); }
 
        bool contains(const Key &key) const { return m_impl.contains(key); }
 
        int count(const Key &key) const { return m_impl.count(key); }
 
        int count() const { return m_impl.count(); }
 
        bool empty() const { return m_impl.empty(); }
 
        iterator erase(iterator pos) { return m_impl.erase(pos); }
 
        iterator insert(const Key &key, const Value &value) { return m_impl.insert(key, value); }
 
        void insert(const CDictionary &other)
        {
            for (auto i = other.cbegin(); i != other.cend(); ++i) { insert(i.key(), i.value()); }
        }
 
        bool isEmpty() const { return m_impl.isEmpty(); }
 
        const Key key(const Value &value) const { return m_impl.key(value); }
 
        const Key key(const Value &value, const Key &defaultKey) const { return m_impl.key(value, defaultKey); }
 
        auto keys() const { return makeRange(keyBegin(), keyEnd()); }
 
        int remove(const Key &key) { return m_impl.remove(key); }
 
        int size() const { return m_impl.size(); }
 
        void swap(CDictionary &other) noexcept { m_impl.swap(other.m_impl); }
 
        const Value value(const Key &key) const { return m_impl.value(key); }
 
        const Value value(const Key &key, const Value &defaultValue) const { return m_impl.value(key, defaultValue); }
 
        CRange<const_iterator> values() const { return makeRange(begin(), end()); }
 
        CDictionary &operator=(const CDictionary &other)
        {
            m_impl = other.m_impl;
            return *this;
        }
 
        CDictionary &operator=(CDictionary &&other) noexcept
        {
            m_impl = std::move(other.m_impl);
            return *this;
        }
 
        friend impl_type &implementationOf(CDictionary &dict) { return dict.m_impl; }
 
        friend const impl_type &implementationOf(const CDictionary &dict) { return dict.m_impl; }
 
        Value &operator[](const Key &key) { return m_impl[key]; }
 
        const Value operator[](const Key &key) const { return m_impl[key]; }
 
        friend bool operator==(const CDictionary &a, const CDictionary &b) { return a.m_impl == b.m_impl; }
 
        friend bool operator!=(const CDictionary &a, const CDictionary &b) { return !(a == b); }
 
        QString convertToQString(bool i18n = false) const
        {
            QString str;
            for (auto it = m_impl.cbegin(); it != m_impl.end(); ++it)
            {
                str += "{";
                str +=
                    CContainerHelper::stringify(it.key(), i18n) + "," + CContainerHelper::stringify(it.value(), i18n);
                str += "}";
            }
            return "{" + str + "}";
        }
 
    public:
        void marshallToDbus(QDBusArgument &argument) const { argument << m_impl; }
 
        void unmarshallFromDbus(const QDBusArgument &argument) { argument >> m_impl; }
 
        void marshalToDataStream(QDataStream &stream) const { stream << m_impl; }
 
        void unmarshalFromDataStream(QDataStream &stream) { stream >> m_impl; }
 
    private:
        Impl<Key, Value> m_impl;
    };
 
    template <class Key, class Value>
    QMap<Key, Value> &implementationOf(QMap<Key, Value> &dict)
    {
        return dict;
    }
 
    template <class Key, class Value>
    const QMap<Key, Value> &implementationOf(const QMap<Key, Value> &dict)
    {
        return dict;
    }
 
    template <class Map1, class Map2, class F>
    void forEachIntersection(const Map1 &map1, const Map2 &map2, F functor)
    {
        static_assert(std::is_same_v<typename Map1::key_type, typename Map2::key_type>,
                      "Maps must have the same key type");
        if (map1.empty() || map2.empty()) { return; }
        auto it1 = implementationOf(map1).lowerBound(map2.cbegin().key());
        auto end1 = implementationOf(map1).upperBound((map2.cend() - 1).key());
        auto it2 = implementationOf(map2).lowerBound(map1.cbegin().key());
        auto end2 = implementationOf(map2).upperBound((map1.cend() - 1).key());
        while (it1 != end1 && it2 != end2)
        {
            if (it1.key() < it2.key()) { ++it1; }
            else if (it2.key() < it1.key()) { ++it2; }
            else
            {
                functor(it1.key(), it1.value(), it2);
                ++it1;
                ++it2;
            }
        }
    }
} // namespace swift::misc
 
#endif // SWIFT_MISC_DICTIONARY_H