propertyindexvariantmap.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_PROPERTYINDEXVARIANTMAP_H
#define SWIFT_MISC_PROPERTYINDEXVARIANTMAP_H
 
#include <type_traits>
 
#include <QDBusArgument>
#include <QList>
#include <QMap>
#include <QMetaType>
#include <QString>
#include <QVariant>
#include <QtGlobal>
 
#include "misc/mixin/mixindbus.h"
#include "misc/mixin/mixinindex.h"
#include "misc/mixin/mixinmetatype.h"
#include "misc/mixin/mixinstring.h"
#include "misc/propertyindex.h"
#include "misc/propertyindexlist.h"
#include "misc/swiftmiscexport.h"
#include "misc/variant.h"
 
namespace swift::misc
{
    class SWIFT_MISC_EXPORT CPropertyIndexVariantMap :
        public mixin::MetaType<CPropertyIndexVariantMap>,
        public mixin::DBusOperators<CPropertyIndexVariantMap>,
        public mixin::DataStreamOperators<CPropertyIndexVariantMap>,
        public mixin::String<CPropertyIndexVariantMap>
    {
    public:
        CPropertyIndexVariantMap(bool wildcard = false);
 
        CPropertyIndexVariantMap(const CPropertyIndex &index, const CVariant &value);
 
        void addValue(const CPropertyIndex &index, const CVariant &value);
 
        void addValue(const CPropertyIndex &index, const QVariant &value) { this->addValue(index, CVariant(value)); }
 
        void addValue(const CPropertyIndex &index, const char *str);
 
        template <class T>
        void addValue(const CPropertyIndex &index, const T &value)
        {
            m_values.insert(index, CVariant::fromValue(value));
        }
 
        void prependIndex(int index);
 
        bool isEmpty() const { return m_values.isEmpty(); }
 
        CVariant value(const CPropertyIndex &index) const { return m_values.value(index); }
 
        void value(const CPropertyIndex &index, const CVariant &value) { m_values.value(index, value); }
 
        CPropertyIndexList indexes() const;
 
        bool contains(const CPropertyIndex &index) const { return m_values.contains(index); }
 
        QList<CVariant> values() const { return m_values.values(); }
 
        bool isWildcard() const { return m_wildcard; }
 
        void setWildcard(bool wildcard) { m_wildcard = wildcard; }
 
        void clear() { m_values.clear(); }
 
        int size() const;
 
        SWIFT_MISC_EXPORT friend bool operator==(const CPropertyIndexVariantMap &a, const CPropertyIndexVariantMap &b);
 
        SWIFT_MISC_EXPORT friend bool operator!=(const CPropertyIndexVariantMap &a, const CPropertyIndexVariantMap &b);
 
        bool matchesVariant(const CVariant &value) const;
 
        template <typename T, typename = std::enable_if_t<!std::is_same_v<T, CVariant>>>
        bool matches(const T &value) const
        {
            return matchesVariant(CVariant::from(value));
        }
 
        const QMap<CPropertyIndex, CVariant> &map() const { return m_values; }
 
        size_t getValueHash() const;
 
        friend size_t qHash(const CPropertyIndexVariantMap &vm) { return vm.getValueHash(); }
 
        QString convertToQString(bool i18n = false) const;
 
    protected:
        QMap<CPropertyIndex, CVariant> m_values; 
        bool m_wildcard; 
 
    public:
        void marshallToDbus(QDBusArgument &argument) const;
 
        void unmarshallFromDbus(const QDBusArgument &argument);
 
        void marshalToDataStream(QDataStream &stream) const;
 
        void unmarshalFromDataStream(QDataStream &stream);
    };
 
    namespace mixin
    {
        template <class Derived>
        CPropertyIndexList Index<Derived>::apply(const swift::misc::CPropertyIndexVariantMap &indexMap,
                                                 bool skipEqualValues)
        {
            if (indexMap.isEmpty()) return {};
 
            CPropertyIndexList changed;
            const auto &map = indexMap.map();
            for (auto it = map.begin(); it != map.end(); ++it)
            {
                const CVariant value = it.value();
                const CPropertyIndex index = it.key();
                if (skipEqualValues)
                {
                    const bool equal = derived()->equalsPropertyByIndex(value, index);
                    if (equal) { continue; }
                }
                derived()->setPropertyByIndex(index, value);
                changed.push_back(index);
            }
            return changed;
        }
    } // namespace mixin
} // namespace swift::misc
 
Q_DECLARE_METATYPE(swift::misc::CPropertyIndexVariantMap)
 
#endif // SWIFT_MISC_PROPERTYINDEXVARIANTMAP_H