logpattern.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2014 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_LOGPATTERN_H
#define SWIFT_MISC_LOGPATTERN_H
 
#include <QDBusArgument>
#include <QMetaType>
#include <QSet>
#include <QString>
#include <QStringList>
#include <QtGlobal>
 
#include "misc/metaclass.h"
#include "misc/mixin/mixincompare.h"
#include "misc/mixin/mixindatastream.h"
#include "misc/mixin/mixindbus.h"
#include "misc/mixin/mixinhash.h"
#include "misc/mixin/mixinicon.h"
#include "misc/mixin/mixinindex.h"
#include "misc/mixin/mixinmetatype.h"
#include "misc/mixin/mixinstring.h"
#include "misc/statusmessage.h"
#include "misc/swiftmiscexport.h"
#include "misc/variant.h"
 
template <class Key, class T>
class QHash;
 
namespace swift::misc
{
    class CLogCategory;
    class CLogCategoryList;
 
    class SWIFT_MISC_EXPORT CLogPattern :
        public mixin::MetaType<CLogPattern>,
        public mixin::HashByMetaClass<CLogPattern>,
        public mixin::EqualsByMetaClass<CLogPattern>,
        public mixin::DBusOperators<CLogPattern>,
        public mixin::DataStreamOperators<CLogPattern>,
        public mixin::Index<CLogPattern>,
        public mixin::String<CLogPattern>,
        public mixin::Icon<CLogPattern>
    {
    public:
        static const QStringList &allHumanReadableNames();
 
        static const CLogPattern &fromHumanReadableName(const QString &name);
 
        static QStringList humanReadableNamesFrom(const CStatusMessage &message);
 
        static QStringList humanOrTechnicalCategoriesFrom(const CStatusMessage &message);
 
        CLogPattern();
 
        static CLogPattern exactMatch(const CLogCategory &category);
 
        static CLogPattern anyOf(const CLogCategoryList &categories);
 
        static CLogPattern allOf(const CLogCategoryList &categories);
 
        static CLogPattern startsWith(const QString &prefix);
 
        static CLogPattern endsWith(const QString &suffix);
 
        static CLogPattern contains(const QString &substring);
 
        static CLogPattern empty();
 
        CLogPattern withSeverity(CStatusMessage::StatusSeverity severity) const;
 
        CLogPattern withSeverities(const QSet<CStatusMessage::StatusSeverity> &severities) const;
 
        CLogPattern withSeverityAtOrAbove(CStatusMessage::StatusSeverity minimumSeverity) const;
 
        bool match(const CStatusMessage &message) const;
 
        bool matches(const CVariant &message) const { return match(message.to<CStatusMessage>()); }
 
        QSet<QString> getCategoryStrings() const { return m_strings; }
 
        bool isProperSubsetOf(const CLogPattern &other) const;
 
        QString convertToQString(bool i18n = false) const;
 
        void marshallToDbus(QDBusArgument &argument) const;
 
        void unmarshallFromDbus(const QDBusArgument &argument);
 
        void marshalToDataStream(QDataStream &stream) const;
 
        void unmarshalFromDataStream(QDataStream &stream);
 
    private:
        bool checkInvariants() const;
 
        enum Strategy
        {
            Everything = 0,
            ExactMatch,
            AnyOf,
            AllOf,
            StartsWith,
            EndsWith,
            Contains,
            Nothing
        };
 
        CLogPattern(Strategy strategy, const QSet<QString> &strings);
 
        QSet<CStatusMessage::StatusSeverity> m_severities;
        Strategy m_strategy;
        QSet<QString> m_strings;
 
        const QString &getString() const
        {
            Q_ASSERT(m_strategy == ExactMatch && m_strings.size() == 1);
            return *m_strings.begin();
        }
        const QString &getPrefix() const
        {
            Q_ASSERT(m_strategy == StartsWith && m_strings.size() == 1);
            return *m_strings.begin();
        }
        const QString &getSuffix() const
        {
            Q_ASSERT(m_strategy == EndsWith && m_strings.size() == 1);
            return *m_strings.begin();
        }
        const QString &getSubstring() const
        {
            Q_ASSERT(m_strategy == Contains && m_strings.size() == 1);
            return *m_strings.begin();
        }
 
        static const QHash<QString, CLogPattern> &allHumanReadablePatterns();
 
        SWIFT_METACLASS(
            CLogPattern,
            SWIFT_METAMEMBER(severities),
            SWIFT_METAMEMBER(strategy),
            SWIFT_METAMEMBER(strings));
    };
} // namespace swift::misc
 
Q_DECLARE_METATYPE(swift::misc::CLogPattern)
 
#endif // SWIFT_MISC_LOGPATTERN_H