statusmessage.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_STATUSMESSAGE_H
#define SWIFT_MISC_STATUSMESSAGE_H
 
#include <QReadWriteLock>
 
#include "misc/logcategorylist.h"
#include "misc/mixin/mixinicon.h"
#include "misc/mixin/mixinstring.h"
#include "misc/orderable.h"
#include "misc/propertyindexref.h"
#include "misc/stringutils.h"
#include "misc/swiftmiscexport.h"
#include "misc/timestampbased.h"
#include "misc/typetraits.h"
 
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc, CStatusMessage)
 
namespace swift::misc
{
    namespace private_ns
    {
        SWIFT_MISC_EXPORT QString arg(QStringView format, const QStringList &args);
    } // namespace private_ns
 
    enum StatusSeverity
    {
        SeverityDebug,
        SeverityInfo,
        SeverityWarning,
        SeverityError
    };
 
    class CStrongStringView :
        public mixin::MetaType<CStrongStringView>,
        public mixin::EqualsByCompare<CStrongStringView>,
        public mixin::LessThanByCompare<CStrongStringView>,
        public mixin::DBusOperators<CStrongStringView>,
        public mixin::DataStreamOperators<CStrongStringView>,
        public mixin::JsonOperators<CStrongStringView>,
        public mixin::String<CStrongStringView>
    {
    public:
        CStrongStringView() = default;
 
        template <size_t N>
        CStrongStringView(const char16_t (&string)[N]) : m_view(string)
        {}
 
        CStrongStringView(const QString &string) : m_string(string), m_view(m_string) {}
 
        explicit CStrongStringView(QStringView view) : m_view(view) {}
 
        CStrongStringView(const char *) = delete;
 
        CStrongStringView(const CStrongStringView &other) { *this = other; }
 
        CStrongStringView &operator=(const CStrongStringView &other)
        {
            if (other.isOwning()) { m_view = m_string = other.m_string; }
            else
            {
                m_view = other.m_view;
                m_string.clear();
            }
            return *this;
        }
 
        ~CStrongStringView() = default;
 
        bool isEmpty() const { return view().isEmpty(); }
 
        bool isOwning() const { return !m_string.isNull(); } // important distinction between isNull and isEmpty
 
        QStringView view() const { return m_view; }
 
        QString convertToQString(bool i18n = false) const
        {
            Q_UNUSED(i18n);
            return isOwning() ? m_string : m_view.toString();
        }
 
        friend int compare(const CStrongStringView &a, const CStrongStringView &b)
        {
            return a.m_view.compare(b.m_view);
        }
 
        friend size_t qHash(const CStrongStringView &obj, uint seed = 0) { return ::qHash(obj.m_view, seed); }
 
        void marshallToDbus(QDBusArgument &arg) const { arg << toQString(); }
        void unmarshallFromDbus(const QDBusArgument &arg)
        {
            arg >> m_string;
            m_view = m_string;
        }
 
        void marshalToDataStream(QDataStream &stream) const { stream << toQString(); }
        void unmarshalFromDataStream(QDataStream &stream)
        {
            stream >> m_string;
            m_view = m_string;
        }
 
        QJsonObject toJson() const
        {
            QJsonObject json;
            json.insert(QStringLiteral("value"), toQString());
            return json;
        }
        void convertFromJson(const QJsonObject &json) { *this = json.value(QLatin1String("value")).toString(); }
 
    private:
        QString m_string;
        QStringView m_view;
    };
 
    template <class Derived>
    class CMessageBase
    {
    public:
        CMessageBase() {}
 
        explicit CMessageBase(const CLogCategory &category) : m_categories({ category }) {}
 
        explicit CMessageBase(const CLogCategoryList &categories) : m_categories(categories) {}
 
        CMessageBase(const CLogCategoryList &categories, const CLogCategory &extra) : CMessageBase(categories)
        {
            this->addIfNotExisting(extra);
        }
 
        CMessageBase(const CLogCategoryList &categories, const CLogCategoryList &extra) : CMessageBase(categories)
        {
            this->addIfNotExisting(extra);
        }
 
        template <size_t N>
        Derived &log(StatusSeverity s, const char16_t (&m)[N])
        {
            m_message = m;
            m_severity = s;
            return derived();
        }
 
        Derived &log(StatusSeverity s, const QString &m)
        {
            m_message = m;
            m_severity = s;
            return derived();
        }
 
        Derived &debug() { return log(SeverityDebug, QString()); }
 
        template <size_t N>
        Derived &debug(const char16_t (&format)[N])
        {
            return log(SeverityDebug, format);
        }
 
        Derived &debug(const QString &format) { return log(SeverityDebug, format); }
 
        template <size_t N>
        Derived &info(const char16_t (&format)[N])
        {
            return log(SeverityInfo, format);
        }
 
        Derived &info(const QString &format) { return log(SeverityInfo, format); }
 
        template <size_t N>
        Derived &warning(const char16_t (&format)[N])
        {
            return log(SeverityWarning, format);
        }
 
        Derived &warning(const QString &format) { return log(SeverityWarning, format); }
 
        template <size_t N>
        Derived &error(const char16_t (&format)[N])
        {
            return log(SeverityError, format);
        }
 
        Derived &error(const QString &format) { return log(SeverityError, format); }
 
        template <size_t N>
        Derived &validation(StatusSeverity s, const char16_t (&format)[N])
        {
            setValidation();
            return log(s, format);
        }
 
        Derived &validation(StatusSeverity s, const QString &format)
        {
            setValidation();
            return log(s, format);
        }
 
        template <size_t N>
        Derived &validationInfo(const char16_t (&format)[N])
        {
            setValidation();
            return log(SeverityInfo, format);
        }
 
        Derived &validationInfo(const QString &format)
        {
            setValidation();
            return log(SeverityInfo, format);
        }
 
        template <size_t N>
        Derived &validationWarning(const char16_t (&format)[N])
        {
            setValidation();
            return log(SeverityWarning, format);
        }
 
        Derived &validationWarning(const QString &format)
        {
            setValidation();
            return log(SeverityWarning, format);
        }
 
        template <size_t N>
        Derived &validationError(const char16_t (&format)[N])
        {
            setValidation();
            return log(SeverityError, format);
        }
 
        Derived &validationError(const QString &format)
        {
            setValidation();
            return log(SeverityError, format);
        }
 
        Derived &log(StatusSeverity, const char *) = delete;
        Derived &debug(const char *) = delete;
        Derived &info(const char *) = delete;
        Derived &warning(const char *) = delete;
        Derived &error(const char *) = delete;
        Derived &validation(StatusSeverity, const char *) = delete;
        Derived &validationInfo(const char *) = delete;
        Derived &validationWarning(const char *) = delete;
        Derived &validationError(const char *) = delete;
 
        template <class T, std::enable_if_t<TParameter<std::decay_t<T>>::passBy == ParameterPassBy::Value, int> = 0>
        Derived &operator<<(T v)
        {
            return arg(TString<T>::toQString(v));
        }
 
        template <class T, std::enable_if_t<TParameter<std::decay_t<T>>::passBy == ParameterPassBy::ConstRef, int> = 0>
        Derived &operator<<(const T &v)
        {
            return arg(TString<T>::toQString(v));
        }
 
        bool isEmpty() const { return this->m_message.isEmpty() && this->m_args.isEmpty(); }
 
    private:
        void setValidation()
        {
            m_categories.remove(CLogCategories::uncategorized());
            this->addIfNotExisting(CLogCategories::validation());
        }
        Derived &arg(const QString &value)
        {
            m_args.push_back(value);
            return derived();
        }
        Derived &derived() { return static_cast<Derived &>(*this); }
 
    protected:
        void addIfNotExisting(const CLogCategory &category)
        {
            if (this->m_categories.contains(category)) { return; }
            this->m_categories.push_back(category);
        }
 
        void addIfNotExisting(const CLogCategoryList &categories)
        {
            if (this->m_categories.isEmpty()) { this->m_categories.push_back(categories); }
            else
            {
                for (const CLogCategory &cat : categories) { this->addIfNotExisting(cat); }
            }
        }
 
    protected:
        CStrongStringView m_message;
 
        QStringList m_args;
 
        CLogCategoryList m_categories = CLogCategoryList { CLogCategories::uncategorized() };
 
        StatusSeverity m_severity = SeverityDebug;
 
        QString message() const { return private_ns::arg(m_message.view(), m_args); }
    };
 
    class SWIFT_MISC_EXPORT CStatusMessage :
        public CValueObject<CStatusMessage>,
        public CMessageBase<CStatusMessage>,
        public ITimestampBased,
        public IOrderable
    {
    public:
        using StatusSeverity = swift::misc::StatusSeverity;
        constexpr static auto SeverityDebug = swift::misc::SeverityDebug;
        constexpr static auto SeverityInfo = swift::misc::SeverityInfo;
        constexpr static auto SeverityWarning = swift::misc::SeverityWarning;
        constexpr static auto SeverityError = swift::misc::SeverityError;
 
        enum ColumnIndex
        {
            IndexCategoriesAsString = CPropertyIndexRef::GlobalIndexCStatusMessage,
            IndexSeverity,
            IndexSeverityAsString,
            IndexSeverityAsIcon,
            IndexMessage,
            IndexMessageNoLineBreaks,
            IndexMessageAsHtml
        };
 
        explicit CStatusMessage(const CLogCategory &category);
 
        explicit CStatusMessage(const CLogCategoryList &categories);
 
        CStatusMessage(const CLogCategoryList &categories, const CLogCategory &extra);
 
        CStatusMessage(const CLogCategoryList &categories, const CLogCategoryList &extra);
 
        CStatusMessage();
 
        CStatusMessage(const CStatusMessage &other);
 
        CStatusMessage &operator=(const CStatusMessage &other);
 
        ~CStatusMessage() = default;
 
        template <size_t N>
        CStatusMessage(const char16_t (&message)[N]) : CStatusMessage(QStringView(message))
        {}
        CStatusMessage(const QString &message);
        template <size_t N>
        CStatusMessage(StatusSeverity severity, const char16_t (&message)[N])
            : CStatusMessage(severity, QStringView(message))
        {}
        CStatusMessage(StatusSeverity severity, const QString &message);
 
        template <size_t N>
        CStatusMessage(const CLogCategoryList &categories, StatusSeverity severity, const char16_t (&message)[N],
                       bool validation = false)
            : CStatusMessage(categories, severity, QStringView(message), validation)
        {}
        CStatusMessage(const CLogCategoryList &categories, StatusSeverity severity, const QString &message,
                       bool validation = false);
 
        explicit CStatusMessage(const char *message) = delete;
        explicit CStatusMessage(StatusSeverity severity, const char *message) = delete;
        explicit CStatusMessage(const CLogCategoryList &categories, StatusSeverity severity, const char *message,
                                bool validation = false) = delete;
 
        CStatusMessage(QtMsgType type, const QMessageLogContext &context, const QString &message);
 
        void toQtLogTriple(QtMsgType *o_type, QString *o_category, QString *o_message) const;
 
        const CLogCategoryList &getCategories() const { return this->m_categories; }
 
        QString getCategoriesAsString() const;
 
        QString getHumanOrTechnicalCategoriesAsString() const;
 
        StatusSeverity getSeverity() const { return this->m_severity; }
 
        bool clampSeverity(StatusSeverity severity);
 
        bool isSeverityInfoOrLess() const
        {
            return this->m_severity == SeverityInfo || this->m_severity == SeverityDebug;
        }
 
        bool isSeverityHigherOrEqual(CStatusMessage::StatusSeverity severity) const;
 
        bool isWarningOrAbove() const
        {
            return this->m_severity == SeverityWarning || this->m_severity == SeverityError;
        }
 
        bool isSuccess() const;
 
        bool isFailure() const;
 
        QString getMessage() const { return this->message(); }
 
        QString getMessageNoLineBreaks() const;
 
        void prependMessage(const QString &msg);
 
        void appendMessage(const QString &msg);
 
        template <class T>
        bool isFromClass(const T *pointer = nullptr) const
        {
            CLogCategoryList classCategories(pointer);
            return std::all_of(classCategories.begin(), classCategories.end(),
                               [this](const CLogCategory &cat) { return m_categories.contains(cat); });
        }
 
        void markAsHandledBy(const QObject *object) const;
 
        bool wasHandledBy(const QObject *object) const;
 
        void setSeverity(StatusSeverity severity) { this->m_severity = severity; }
 
        void addCategory(const CLogCategory &category) { this->addIfNotExisting(category); }
 
        void addValidationCategory() { this->addCategory(CLogCategories::validation()); }
 
        void addCategories(const CLogCategoryList &categories) { this->addIfNotExisting(categories); }
 
        void setCategory(const CLogCategory &category) { this->m_categories = CLogCategoryList { category }; }
 
        void setCategories(const CLogCategoryList &categories) { this->m_categories = categories; }
 
        CIcons::IconIndex toIcon() const { return convertToIcon(*this).getIndex(); }
 
        const QString &getSeverityAsString() const;
 
        const CIcon &getSeverityAsIcon() const;
 
        static const QString &severityToString(StatusSeverity severity);
 
        static QString severitiesToString(const QSet<StatusSeverity> &severities);
 
        static StatusSeverity stringToSeverity(const QString &severity);
 
        static const QStringList &allSeverityStrings();
 
        QVariant propertyByIndex(swift::misc::CPropertyIndexRef index) const;
 
        void setPropertyByIndex(swift::misc::CPropertyIndexRef index, const QVariant &variant);
 
        int comparePropertyByIndex(CPropertyIndexRef index, const CStatusMessage &compareValue) const;
 
        QString convertToQString(bool i18n = false) const;
 
        QString toHtml(bool withIcon, bool withColors) const;
 
        static const CIcon &convertToIcon(const CStatusMessage &statusMessage);
 
        static const CIcon &convertToIcon(CStatusMessage::StatusSeverity severity);
 
        static const QString &convertToIconResource(CStatusMessage::StatusSeverity severity);
 
        static CStatusMessage fromDatabaseJson(const QJsonObject &json);
 
        static CStatusMessage fromJsonException(const CJsonException &ex, const CLogCategoryList &categories,
                                                const QString &prefix);
 
        static void registerMetadata();
 
    private:
        CStatusMessage(QStringView message);
        CStatusMessage(StatusSeverity severity, QStringView message);
        CStatusMessage(const CLogCategoryList &categories, StatusSeverity severity, QStringView message,
                       bool validation);
 
        mutable QVector<quintptr> m_handledByObjects;
        mutable QReadWriteLock m_lock; 
 
        SWIFT_METACLASS(
            CStatusMessage,
            SWIFT_METAMEMBER(categories),
            SWIFT_METAMEMBER(severity),
            SWIFT_METAMEMBER(message),
            SWIFT_METAMEMBER(args),
            SWIFT_METAMEMBER(order, 0, DisabledForHashing | DisabledForComparison),
            SWIFT_METAMEMBER(timestampMSecsSinceEpoch, 0, DisabledForHashing | DisabledForComparison));
    };
 
    // CContainerBase methods implemented out-of-line to avoid circular include
    template <class Derived>
    CStatusMessage CContainerBase<Derived>::convertFromJsonNoThrow(const QJsonObject &json,
                                                                   const CLogCategoryList &categories,
                                                                   const QString &prefix)
    {
        try
        {
            convertFromJson(json);
        }
        catch (const CJsonException &ex)
        {
            return CStatusMessage::fromJsonException(ex, categories, prefix);
        }
        return {};
    }
 
    template <class Derived>
    CStatusMessage CContainerBase<Derived>::convertFromJsonNoThrow(const QString &jsonString,
                                                                   const CLogCategoryList &categories,
                                                                   const QString &prefix)
    {
        try
        {
            convertFromJson(jsonString);
        }
        catch (const CJsonException &ex)
        {
            return CStatusMessage::fromJsonException(ex, categories, prefix);
        }
        return {};
    }
} // namespace swift::misc
 
Q_DECLARE_METATYPE(swift::misc::CStrongStringView)
Q_DECLARE_METATYPE(swift::misc::CStatusMessage)
Q_DECLARE_METATYPE(swift::misc::CStatusMessage::StatusSeverity)
 
#endif // SWIFT_MISC_STATUSMESSAGE_H