threadedreader.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_CORE_THREADED_READER_H
#define SWIFT_CORE_THREADED_READER_H
 
#include <atomic>
 
#include <QDateTime>
#include <QObject>
#include <QPair>
#include <QReadWriteLock>
#include <QString>
#include <QtGlobal>
 
#include "core/swiftcoreexport.h"
#include "core/vatsim/vatsimsettings.h"
#include "misc/logcategories.h"
#include "misc/network/urlloglist.h"
#include "misc/worker.h"
 
class QNetworkReply;
class QTimer;
 
namespace swift::core
{
    class SWIFT_CORE_EXPORT CThreadedReader : public swift::misc::CContinuousWorker
    {
        Q_OBJECT
 
    public:
        static const QStringList &getLogCategories();
 
        virtual ~CThreadedReader();
 
        QDateTime getUpdateTimestamp() const;
 
        void setUpdateTimestamp(const QDateTime &updateTimestamp = QDateTime::currentDateTimeUtc());
 
        bool updatedWithinLastMs(qint64 timeLastMs);
 
        bool isMarkedAsFailed() const;
 
        void setMarkedAsFailed(bool failed);
 
        swift::misc::network::CUrlLogList getReadLog() const;
 
        void startReader();
 
        void pauseReader();
 
        void markAsUsedInUnitTest() { m_unitTest = true; }
 
        bool hasPendingUrls() const;
 
        swift::misc::network::CUrlLogList getUrlLogList() const;
 
        int getNetworkReplyProgress() const { return m_networkReplyProgress; }
 
        QPair<qint64, qint64> getNetworkReplyBytes() const;
 
    protected:
        mutable QReadWriteLock m_lock {
            QReadWriteLock::Recursive
        }; 
        std::atomic_int m_networkReplyProgress; 
        std::atomic_llong m_networkReplyCurrent; 
        std::atomic_llong m_networkReplyNax; 
 
        CThreadedReader(QObject *owner, const QString &name);
 
        qint64 lastModifiedMsSinceEpoch(QNetworkReply *nwReply) const;
 
        void threadAssertCheck() const;
 
        bool didContentChange(const QString &content, int startPosition = -1);
 
        void setInitialAndPeriodicTime(int initialTime, int periodicTime);
 
        virtual void doWorkImpl() {}
 
        bool doWorkCheck() const;
 
        QNetworkReply *getFromNetworkAndLog(const swift::misc::network::CUrl &url,
                                            const swift::misc::CSlot<void(QNetworkReply *)> &callback);
 
        virtual void networkReplyProgress(int logId, qint64 current, qint64 max, const QUrl &url);
 
        void logNetworkReplyReceived(QNetworkReply *reply);
 
        static void logInconsistentData(const swift::misc::CStatusMessage &msg, const char *funcInfo = nullptr);
 
    private:
        void doWork();
 
        static constexpr int OutdatedPendingCallMs = 30 * 1000; 
 
        int m_initialTime = -1; 
        int m_periodicTime = -1; 
        QDateTime m_updateTimestamp; 
        size_t m_contentHash = 0; 
        std::atomic_bool m_markedAsFailed { false }; 
        bool m_unitTest { false }; 
        swift::misc::network::CUrlLogList m_urlReadLog; 
    };
} // namespace swift::core
 
#endif // SWIFT_CORE_THREADED_READER_H