variant.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_VARIANT_H
#define SWIFT_MISC_VARIANT_H
 
#include <algorithm>
#include <type_traits>
 
#include <QDBusArgument>
#include <QDateTime>
#include <QJsonObject>
#include <QMetaType>
#include <QPixmap>
#include <QSequentialIterable>
#include <QString>
#include <QVariant>
#include <QtGlobal>
 
#include "misc/icons.h"
#include "misc/inheritancetraits.h"
#include "misc/mixin/mixincompare.h"
#include "misc/mixin/mixindatastream.h"
#include "misc/mixin/mixindbus.h"
#include "misc/mixin/mixinjson.h"
#include "misc/mixin/mixinstring.h"
#include "misc/range.h"
#include "misc/swiftmiscexport.h"
#include "misc/variantprivate.h"
 
namespace swift::misc
{
    class CIcon;
    class CPropertyIndex;
 
    template <typename T>
    void registerMetaValueType()
    {
        if (QMetaType::hasRegisteredConverterFunction<T, private_ns::IValueObjectMetaInfo *>()) { return; }
        bool ok = QMetaType::registerConverter<T, private_ns::IValueObjectMetaInfo *>(
            private_ns::CValueObjectMetaInfo<T>::instance);
        Q_ASSERT(ok);
        Q_UNUSED(ok);
    }
 
    class SWIFT_MISC_EXPORT CVariant :
        public mixin::EqualsByCompare<CVariant>,
        public mixin::LessThanByCompare<CVariant>,
        public mixin::DBusOperators<CVariant>,
        public mixin::DataStreamOperators<CVariant>,
        public mixin::JsonOperators<CVariant>,
        public mixin::String<CVariant>
    {
        template <typename>
        struct tag
        {};
 
    public:
        CVariant() {}
 
        CVariant(const CVariant &) = default;
 
        CVariant(CVariant &&other) noexcept = default;
 
        CVariant(const QVariant &var) : m_v(var) {}
 
        CVariant(QVariant &&var) noexcept : m_v(std::move(var)) {}
 
        CVariant(int) = delete;
 
        CVariant(const QString &string) : m_v(string) {}
 
        CVariant(const char *string) : m_v(string) {}
 
        CVariant(int typeId, const void *copy) : m_v(QMetaType(typeId), copy) {}
 
        friend size_t qHash(const CVariant &var) { return var.getValueHash(); }
 
        void reset(const QVariant &var) { m_v = var; }
 
        void reset(QVariant &&var) { m_v = std::move(var); }
 
        CVariant &operator=(const CVariant &other) = default;
 
        CVariant &operator=(CVariant &&other) noexcept = default;
 
        CVariant &operator=(const QVariant &var)
        {
            m_v = var;
            return *this;
        }
 
        CVariant &operator=(QVariant &&var) noexcept
        {
            m_v = std::move(var);
            return *this;
        }
 
        void swap(CVariant &other) noexcept { m_v.swap(other.m_v); }
 
        void swap(QVariant &other) noexcept { m_v.swap(other); }
 
        template <typename T>
        static CVariant fromValue(T &&value)
        {
            static_assert(!std::is_same_v<CVariant, std::decay_t<T>>, "CVariant is an illegal type!");
            return CVariant(QVariant::fromValue(std::forward<T>(value)));
        }
 
        template <typename T>
        static CVariant from(T &&value)
        {
            static_assert(!std::is_same_v<CVariant, std::decay_t<T>>, "CVariant is an illegal type!");
            return CVariant(QVariant::fromValue(std::forward<T>(value)));
        }
 
        template <typename T>
        void setValue(T &&value)
        {
            m_v.setValue(std::forward<T>(value));
        }
 
        template <typename T>
        void set(T &&value)
        {
            m_v.setValue(std::forward<T>(value));
        }
 
        template <typename T>
        T value() const
        {
            return to(tag<T>());
        }
 
        template <typename T>
        T to() const
        {
            return to(tag<T>());
        }
 
        template <typename T>
        T valueOrDefault(T def) const
        {
            return canConvert<T>() ? value<T>() : def;
        }
 
        const QVariant &getQVariant() const { return m_v; }
 
        operator const QVariant &() const { return m_v; }
 
        operator QVariant() && { return std::move(m_v); }
 
        bool canConvert(int typeId) const;
 
        template <typename T>
        bool canConvert() const
        {
            return canConvert(qMetaTypeId<T>());
        }
 
        bool convert(int typeId);
 
        QString convertToQString(bool i18n = false) const;
 
        bool isIntegral() const;
 
        bool isArithmetic() const;
 
        bool toBool() const { return m_v.toBool(); }
 
        int toInt(bool *ok = nullptr) const { return m_v.toInt(ok); }
 
        qlonglong toLongLong(bool *ok = nullptr) const { return m_v.toLongLong(ok); }
 
        qulonglong toULongLong(bool *ok = nullptr) const { return m_v.toULongLong(ok); }
 
        qint64 toQInt64(bool *ok = nullptr) const;
 
        double toDouble(bool *ok = nullptr) const { return m_v.toDouble(ok); }
 
        QDateTime toDateTime() const { return m_v.toDateTime(); }
 
        QUrl toUrl() const { return m_v.toUrl(); }
 
        void clear() { m_v.clear(); }
 
        bool isNull() const { return m_v.isNull(); }
 
        bool isValid() const { return m_v.isValid(); }
 
        QMetaType::Type type() const
        {
            const int type = m_v.typeId();
            return type >= QMetaType::Type::User ? QMetaType::Type::User : static_cast<QMetaType::Type>(type);
        }
 
        const char *typeName() const { return m_v.typeName(); }
 
        int userType() const { return m_v.userType(); }
 
        QMetaType metaType() const { return QMetaType(userType()); }
 
        QJsonObject toJson() const;
 
        QString toJsonString(QJsonDocument::JsonFormat format = QJsonDocument::Indented) const;
 
        void convertFromJson(const QJsonObject &json);
 
        CStatusMessage convertFromJsonNoThrow(const QJsonObject &json, const CLogCategoryList &categories,
                                              const QString &prefix);
 
        QJsonObject toMemoizedJson() const;
 
        void convertFromMemoizedJson(const QJsonObject &json, bool allowFallbackToJson);
 
        CStatusMessage convertFromMemoizedJsonNoThrow(const QJsonObject &json, const CLogCategoryList &categories,
                                                      const QString &prefix);
 
        void marshallToDbus(QDBusArgument &argument) const;
 
        void unmarshallFromDbus(const QDBusArgument &argument);
 
        void marshalToDataStream(QDataStream &stream) const;
 
        void unmarshalFromDataStream(QDataStream &stream);
 
        friend int compare(const CVariant &a, const CVariant &b) { return compareImpl(a, b); }
 
        void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
        QVariant propertyByIndex(swift::misc::CPropertyIndexRef index) const;
 
        bool equalsPropertyByIndex(const CVariant &compareValue, CPropertyIndexRef index) const;
 
        QPixmap toPixmap() const;
 
        CIcons::IconIndex toIcon() const;
 
        static void registerMetadata();
 
        int getMetaTypeId() const;
 
        QString getClassName() const;
 
        bool isA(int metaTypeId) const;
 
        bool matches(const CVariant &event) const;
 
    private:
        QVariant m_v;
 
        private_ns::IValueObjectMetaInfo *getValueObjectMetaInfo() const
        {
            return private_ns::getValueObjectMetaInfo(m_v);
        }
        void *data() { return m_v.data(); }
        const void *data() const { return m_v.data(); }
 
        static int compareImpl(const CVariant &, const CVariant &);
        size_t getValueHash() const;
 
        template <typename T>
        T to(tag<T>) const
        {
            auto copy = *this;
            copy.convert(qMetaTypeId<T>());
            return *static_cast<const T *>(copy.data());
        }
        template <typename T>
        QList<T> to(tag<QList<T>>) const
        {
            return toImpl<QList<T>>();
        }
        template <typename T>
        CSequence<T> to(tag<CSequence<T>>) const
        {
            return toImpl<CSequence<T>>();
        }
        template <typename T>
        T toImpl() const
        {
            using VT = typename T::value_type;
            T result;
            if (isVariantList())
            {
                for (const auto &v : m_v.value<QVector<CVariant>>()) { result.push_back(v.value<VT>()); }
            }
            else
            {
                for (const auto &v : m_v.value<QSequentialIterable>()) { result.push_back(v.value<VT>()); }
            }
            return result;
        }
        bool isVariantList() const;
    };
} // namespace swift::misc
 
Q_DECLARE_METATYPE(swift::misc::CVariant)
 
namespace swift::misc::private_ns
{
    template <typename T>
    void MetaTypeHelper<T>::maybeRegisterMetaList()
    {
        if constexpr (canConvertVariantList<T>(0))
        {
            if (QMetaType::hasRegisteredConverterFunction(QMetaType(qMetaTypeId<T>()),
                                                          QMetaType(qMetaTypeId<QVector<CVariant>>())))
            {
                return;
            }
 
            QMetaType::registerConverter<T, QVector<CVariant>>([](const T &list) -> QVector<CVariant> {
                return list.transform([](const typename T::value_type &v) { return CVariant::from(v); });
            });
            QMetaType::registerConverter<QVector<CVariant>, T>([](const QVector<CVariant> &list) -> T {
                return makeRange(list).transform([](const CVariant &v) { return v.to<typename T::value_type>(); });
            });
        }
    }
} // namespace swift::misc::private_ns
 
#endif // SWIFT_MISC_VARIANT_H