loghandler.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_LOGHANDLER_H
#define SWIFT_MISC_LOGHANDLER_H
 
#include <atomic>
#include <utility>
 
#include <QHash>
#include <QList>
#include <QMetaMethod>
#include <QMetaObject>
#include <QObject>
#include <QPointer>
#include <QThread>
#include <QTimer>
#include <QtGlobal>
#include <QtMessageHandler>
 
#include "misc/logcategory.h"
#include "misc/logpattern.h"
#include "misc/statusmessage.h"
#include "misc/swiftmiscexport.h"
#include "misc/tokenbucket.h"
 
namespace swift::misc
{
    class CLogPatternHandler;
 
    class SWIFT_MISC_EXPORT CLogHandler : public QObject
    {
        Q_OBJECT
 
    public:
        CLogHandler();
 
        ~CLogHandler() override;
 
        static CLogHandler *instance();
 
        void install(bool skipIfAlreadyInstalled = false);
 
        CLogPatternHandler *handlerForPattern(const CLogPattern &pattern);
 
        CLogPatternHandler *handlerForCategory(const CLogCategory &category);
 
        CLogPatternHandler *handlerForValidation()
        {
            return handlerForPattern(CLogPattern::exactMatch(CLogCategories::validation())
                                         .withSeverityAtOrAbove(CStatusMessage::SeverityWarning));
        }
 
        QList<CLogPattern> getAllSubscriptions() const;
 
    signals:
        void localMessageLogged(const swift::misc::CStatusMessage &message);
 
        void remoteMessageLogged(const swift::misc::CStatusMessage &message);
 
        void subscriptionAdded(const swift::misc::CLogPattern &pattern);
 
        void subscriptionRemoved(const swift::misc::CLogPattern &pattern);
 
    public slots:
        void logLocalMessage(const swift::misc::CStatusMessage &message);
 
        void logRemoteMessage(const swift::misc::CStatusMessage &message);
 
        void enableConsoleOutput(bool enable);
 
    private:
        friend class CLogPatternHandler;
        void logMessage(const swift::misc::CStatusMessage &message);
        QtMessageHandler m_oldHandler = nullptr;
        bool m_enableFallThrough = true;
        bool isFallThroughEnabled(const QList<CLogPatternHandler *> &handlers) const;
        using PatternPair = std::pair<CLogPattern, CLogPatternHandler *>;
        QList<PatternPair> m_patternHandlers;
        QList<CLogPatternHandler *> handlersForMessage(const CStatusMessage &message) const;
        void removePatternHandler(CLogPatternHandler *);
        QHash<CStatusMessage, std::pair<CTokenBucket, int>> m_tokenBuckets;
    };
 
    class SWIFT_MISC_EXPORT CLogPatternHandler : public QObject
    {
        Q_OBJECT
 
    public slots:
        void enableConsoleOutput(bool enable)
        {
            Q_ASSERT(thread() == QThread::currentThread());
            m_inheritFallThrough = false;
            m_enableFallThrough = enable;
            m_subscriptionNeedsUpdate = true;
        }
 
        void inheritConsoleOutput()
        {
            Q_ASSERT(thread() == QThread::currentThread());
            m_inheritFallThrough = true;
            m_subscriptionNeedsUpdate = true;
        }
 
    signals:
        void messageLogged(const swift::misc::CStatusMessage &message);
 
    public:
        template <typename T, typename F>
        QMetaObject::Connection subscribe(T *receiver, F slot)
        {
            return connect(this, &CLogPatternHandler::messageLogged, receiver, slot);
        }
 
        template <typename F>
        QMetaObject::Connection subscribe(F slot)
        {
            return connect(this, &CLogPatternHandler::messageLogged, slot);
        }
 
    protected:
        void connectNotify(const QMetaMethod &signal) override
        {
            if (signal == QMetaMethod::fromSignal(&CLogPatternHandler::messageLogged))
            {
                m_subscriptionNeedsUpdate = true;
            }
        }
 
        void disconnectNotify(const QMetaMethod &signal) override
        {
            if (signal == QMetaMethod::fromSignal(&CLogPatternHandler::messageLogged))
            {
                m_subscriptionNeedsUpdate = true;
            }
        }
 
    private:
        friend class CLogHandler;
        CLogPatternHandler(CLogHandler *parent, const CLogPattern &pattern);
        CLogHandler *m_parent = nullptr;
        CLogPattern m_pattern;
        bool m_inheritFallThrough = true;
        bool m_enableFallThrough = true;
        bool m_isSubscribed = false;
        std::atomic<bool> m_subscriptionNeedsUpdate { false };
        QTimer m_subscriptionUpdateTimer;
        void updateSubscription();
    };
 
    class SWIFT_MISC_EXPORT CLogSubscriber : public QObject
    {
        Q_OBJECT
 
    public:
        CLogSubscriber(QObject *parent = nullptr) : QObject(parent) {}
 
        template <typename T, typename F>
        CLogSubscriber(T *parent, F slot) : QObject(parent)
        {
            QObject::connect(this, &CLogSubscriber::ps_messageLogged, parent, slot);
        }
 
        void changeSubscription(const CLogPattern &pattern);
 
        void unsubscribe();
 
        void enableConsoleOutput(bool enable);
 
        void inheritConsoleOutput();
 
    signals:
        void ps_messageLogged(const swift::misc::CStatusMessage &message);
 
    private slots:
        void ps_logMessage(const swift::misc::CStatusMessage &message) { emit ps_messageLogged(message); }
 
    private:
        QPointer<CLogPatternHandler> m_handler;
        bool m_inheritFallThrough = true;
        bool m_enableFallThrough = true;
    };
} // namespace swift::misc
 
#endif // SWIFT_MISC_LOGHANDLER_H