controller/FolderFlagSync.h - GCC Code Coverage Report

Directory:	src/
Coverage:	low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%

	Coverage	Exec / Excl / Total
Lines:	100.0%	7 / 0 / 7
Functions:	100.0%	4 / 0 / 4
Branches:	-%	0 / 0 / 0

    controller/FolderFlagSync.h
    
        Line
        Branch
        Exec
        Source
      
        #pragma once
      
        #include "controller/FolderContext.h"
      
        #include "controller/PendingFlagIntents.h"
      
        #include <QElapsedTimer>
      
        #include <QHash>
      
        #include <QList>
      
        #include <QObject>
      
        #include <QPair>
      
        #include <QStringList>
      
        #include <QThreadPool>
      
        #include <atomic>
      
        #include <functional>
      
        #include <memory>
      
        #include <optional>
      
        class ImapService;
      
        class MailCache;
      
        class MailListModel;
      
        class MailThreadModel;
      
        class QTimer;
      
        struct StatusResult;
      
        // Live flag and count synchronisation of the selected folder (Sprint 91
      
        // S91.2.6, extracted from MailController): IDLE pushes, FETCH FLAGS /
      
        // CONDSTORE snapshot reconciliation (small folders on the GUI thread, large
      
        // ones on a read-only worker), STATUS polling of the subscribed folders and
      
        // the IDLE/NOTIFY restart that ends a folder open. Callers reach it as
      
        // `controller.flagSync()`.
      
        //
      
        // Owner: MailController (value member). GUI thread; the membership diff
      
        // runs on the unit's two-thread pool with its own read-only cache
      
        // connection. MailController connects the main connection's IDLE, flag and
      
        // STATUS signals (and the search connection's STATUS signal) to the unit
      
        // at the former positions, so receiver order is unchanged. The folder
      
        // context, pending intents, subscribed folders and header-stream state stay
      
        // owned by the controller (references / Deps); finishFlagSync — which
      
        // continues the header-stream sequence — stays in the controller and is
      
        // called through Deps. Controller signals keep their emitter (notifiers).
      
        class FolderFlagSync final : public QObject {
      
          Q_OBJECT
      
        public:
      
          struct Deps {
      
            std::function<void()> ensureSearchConnection;
      
            std::function<bool()> beginHeaderStream;
      
            std::function<int()> pendingHeaderWrites;
      
            std::function<void(const QString &)> failHeaderWrite;
      
            // Keep the newest complete flag snapshot until the header writes settle.
      
            std::function<void(const QList<QPair<qint64, quint32>> &)> deferHeaderFlags;
      
            std::function<void()> resyncCurrentFolder;
      
            std::function<void(QList<qint64>, bool)> finishFlagSync;
      
            std::function<void()> requestFolderCountStatus;
      
            // MailController signals (the emitter stays the controller).
      
            std::function<void(const QString &)> statusMessage;
      
            std::function<void(const QString &, int)> unreadCountChanged;
      
            std::function<void(const QString &, int)> cachedUnreadCountChanged;
      
            std::function<void(qint64, int, quint64)> authoritativeFolderPresented;
      
          };
      
          FolderFlagSync(ImapService *imap, ImapService *const &searchImap, MailCache *cache,
      
                         MailListModel *model, MailThreadModel *const &threadModel,
      
                         const FolderContext &folder, PendingFlagIntents &flagIntents,
      
                         const QStringList &subscribedFolders, const bool &folderPresentationEnabled,
      
                         QElapsedTimer &folderSwitchStopwatch, Deps deps, QObject *parent = nullptr);
      
          // Polling and expunge-debounce timers; called at the end of the
      
          // controller constructor (their former position).
      
          void connectTimers();
      
          // Quick's published indexed page can supply visible flags when the hidden
      
          // flat model has no copy of those rows. Called only on the GUI thread.
      
        795
          void setVisibleIndexedFlagsProvider(
      
              std::function<QHash<qint64, quint32>(qint64)> provider) {
      
        795
            m_visibleIndexedFlags = std::move(provider);
      
        795
          }
      
          // Sprint 49: Trigger immediate poll of all subscribed folders
      
          void triggerPollNow();
      
          // Folder open finished its sync: NOTIFY or IDLE (plus STATUS polling).
      
          void startIdleIfPossible();
      
          // Controller state transitions (folder/account switch, teardown).
      
          void cancelMembershipRead();   // new sequence, cancel the running diff
      
          void abortMembershipRead();    // cancel only (destructor)
      
          void waitForMembershipReads();
      
          void stopPolling();
      
          void restartPolling();         // stop, then start when folders are subscribed
      
          void resetPollingIndex();
      
          void clearChangedSinceFlags();
      
          // Observable state (tests and diagnostics).
      
          bool expungeRefreshPending() const;
      
          bool pollingActive() const;
      
        2
          bool initialPollDone() const { return m_initialPollDone; }
      
        3
          int pollingIndex() const { return m_pollingIndex; }
      
        4
          void setPollingIndex(int index) { m_pollingIndex = index; }
      
        public slots:
      
          // IDLE event handlers
      
          void onIdleNewMessages(int newCount);
      
          void onIdleFlagsChanged(qint64 uid, quint32 flags);
      
          void onIdleFlagsNeedRefetch(int seqNo);
      
          void onIdleMessageExpunged(int seqNo);
      
          // Flag sync result
      
          void onFlagsReceived(const QList<QPair<qint64, quint32>> &uidFlags);
      
          void onChangedFlagsReceived(const QList<QPair<qint64, quint32>> &uidFlags);
      
          void onUidMembershipReceived(const QList<qint64> &uids);
      
          // Folder status (polling) result
      
          void onFolderStatusReceived(const StatusResult &result);
      
          // F-26: a failed STATUS keeps the round going (failure isolation).
      
          void onFolderStatusFailed(const QString &folder);
      
          // Polling timer
      
          void pollFolders();
      
          void pollNextFolder();
      
        private:
      
          // `membership` set: CONDSTORE reopen (uidFlags holds only changed mail).
      
          void reconcileLargeFlagSnapshot(const QList<QPair<qint64, quint32>> &uidFlags,
      
        6
                                          std::optional<QList<qint64>> membership = std::nullopt);
      
          bool idlePushBelongsToCurrentFolder() const;
      
          ImapService *m_imap;
      
          ImapService *const &m_searchImap;       // owned by MailController (lazy)
      
          MailCache *m_cache;
      
          MailListModel *m_model;
      
          MailThreadModel *const &m_threadModel;  // set later on MailController
      
          const FolderContext &m_folder;          // MailController::m_folder
      
          PendingFlagIntents &m_flagIntents;      // MailMutationPipeline::intents()
      
          const QStringList &m_subscribedFolders; // MailController::m_subscribedFolders
      
          const bool &m_folderPresentationEnabled;
      
          QElapsedTimer &m_folderSwitchStopwatch; // started by the folder switch
      
          Deps m_deps;
      
          QTimer *m_pollingTimer = nullptr;
      
          int m_pollingIndex = 0;
      
          bool m_initialPollDone = false;    // T-066: initial poll on first IDLE start
      
          // Debounce timer for IDLE expunge events (avoid N× fetchFlags for bulk deletes)
      
          QTimer *m_expungeDebounceTimer = nullptr;
      
          QThreadPool m_flagMembershipPool;
      
          std::shared_ptr<std::atomic_bool> m_flagMembershipCancelled;
      
          quint64 m_flagMembershipSequence = 0;
      
          std::function<QHash<qint64, quint32>(qint64)> m_visibleIndexedFlags;
      
          QList<QPair<qint64, quint32>> m_changedSinceFlags;
      
        };

Line	Exec	Source
1		#pragma once
2
3		#include "controller/FolderContext.h"
4		#include "controller/PendingFlagIntents.h"
5		#include <QElapsedTimer>
6		#include <QHash>
7		#include <QList>
8		#include <QObject>
9		#include <QPair>
10		#include <QStringList>
11		#include <QThreadPool>
12		#include <atomic>
13		#include <functional>
14		#include <memory>
15		#include <optional>
16
17		class ImapService;
18		class MailCache;
19		class MailListModel;
20		class MailThreadModel;
21		class QTimer;
22		struct StatusResult;
23
24		// Live flag and count synchronisation of the selected folder (Sprint 91
25		// S91.2.6, extracted from MailController): IDLE pushes, FETCH FLAGS /
26		// CONDSTORE snapshot reconciliation (small folders on the GUI thread, large
27		// ones on a read-only worker), STATUS polling of the subscribed folders and
28		// the IDLE/NOTIFY restart that ends a folder open. Callers reach it as
29		// `controller.flagSync()`.
30		//
31		// Owner: MailController (value member). GUI thread; the membership diff
32		// runs on the unit's two-thread pool with its own read-only cache
33		// connection. MailController connects the main connection's IDLE, flag and
34		// STATUS signals (and the search connection's STATUS signal) to the unit
35		// at the former positions, so receiver order is unchanged. The folder
36		// context, pending intents, subscribed folders and header-stream state stay
37		// owned by the controller (references / Deps); finishFlagSync — which
38		// continues the header-stream sequence — stays in the controller and is
39		// called through Deps. Controller signals keep their emitter (notifiers).
40		class FolderFlagSync final : public QObject {
41		Q_OBJECT
42		public:
43		struct Deps {
44		std::function<void()> ensureSearchConnection;
45		std::function<bool()> beginHeaderStream;
46		std::function<int()> pendingHeaderWrites;
47		std::function<void(const QString &)> failHeaderWrite;
48		// Keep the newest complete flag snapshot until the header writes settle.
49		std::function<void(const QList<QPair<qint64, quint32>> &)> deferHeaderFlags;
50		std::function<void()> resyncCurrentFolder;
51		std::function<void(QList<qint64>, bool)> finishFlagSync;
52		std::function<void()> requestFolderCountStatus;
53		// MailController signals (the emitter stays the controller).
54		std::function<void(const QString &)> statusMessage;
55		std::function<void(const QString &, int)> unreadCountChanged;
56		std::function<void(const QString &, int)> cachedUnreadCountChanged;
57		std::function<void(qint64, int, quint64)> authoritativeFolderPresented;
58		};
59		FolderFlagSync(ImapService imap, ImapService const &searchImap, MailCache *cache,
60		MailListModel model, MailThreadModel const &threadModel,
61		const FolderContext &folder, PendingFlagIntents &flagIntents,
62		const QStringList &subscribedFolders, const bool &folderPresentationEnabled,
63		QElapsedTimer &folderSwitchStopwatch, Deps deps, QObject *parent = nullptr);
64		// Polling and expunge-debounce timers; called at the end of the
65		// controller constructor (their former position).
66		void connectTimers();
67
68		// Quick's published indexed page can supply visible flags when the hidden
69		// flat model has no copy of those rows. Called only on the GUI thread.
70	795	void setVisibleIndexedFlagsProvider(
71		std::function<QHash<qint64, quint32>(qint64)> provider) {
72	795	m_visibleIndexedFlags = std::move(provider);
73	795	}
74		// Sprint 49: Trigger immediate poll of all subscribed folders
75		void triggerPollNow();
76		// Folder open finished its sync: NOTIFY or IDLE (plus STATUS polling).
77		void startIdleIfPossible();
78
79		// Controller state transitions (folder/account switch, teardown).
80		void cancelMembershipRead(); // new sequence, cancel the running diff
81		void abortMembershipRead(); // cancel only (destructor)
82		void waitForMembershipReads();
83		void stopPolling();
84		void restartPolling(); // stop, then start when folders are subscribed
85		void resetPollingIndex();
86		void clearChangedSinceFlags();
87
88		// Observable state (tests and diagnostics).
89		bool expungeRefreshPending() const;
90		bool pollingActive() const;
91	2	bool initialPollDone() const { return m_initialPollDone; }
92	3	int pollingIndex() const { return m_pollingIndex; }
93	4	void setPollingIndex(int index) { m_pollingIndex = index; }
94
95		public slots:
96		// IDLE event handlers
97		void onIdleNewMessages(int newCount);
98		void onIdleFlagsChanged(qint64 uid, quint32 flags);
99		void onIdleFlagsNeedRefetch(int seqNo);
100		void onIdleMessageExpunged(int seqNo);
101		// Flag sync result
102		void onFlagsReceived(const QList<QPair<qint64, quint32>> &uidFlags);
103		void onChangedFlagsReceived(const QList<QPair<qint64, quint32>> &uidFlags);
104		void onUidMembershipReceived(const QList<qint64> &uids);
105		// Folder status (polling) result
106		void onFolderStatusReceived(const StatusResult &result);
107		// F-26: a failed STATUS keeps the round going (failure isolation).
108		void onFolderStatusFailed(const QString &folder);
109		// Polling timer
110		void pollFolders();
111		void pollNextFolder();
112
113		private:
114		// `membership` set: CONDSTORE reopen (uidFlags holds only changed mail).
115		void reconcileLargeFlagSnapshot(const QList<QPair<qint64, quint32>> &uidFlags,
116	6	std::optional<QList<qint64>> membership = std::nullopt);
117		bool idlePushBelongsToCurrentFolder() const;
118
119		ImapService *m_imap;
120		ImapService *const &m_searchImap; // owned by MailController (lazy)
121		MailCache *m_cache;
122		MailListModel *m_model;
123		MailThreadModel *const &m_threadModel; // set later on MailController
124		const FolderContext &m_folder; // MailController::m_folder
125		PendingFlagIntents &m_flagIntents; // MailMutationPipeline::intents()
126		const QStringList &m_subscribedFolders; // MailController::m_subscribedFolders
127		const bool &m_folderPresentationEnabled;
128		QElapsedTimer &m_folderSwitchStopwatch; // started by the folder switch
129		Deps m_deps;
130		QTimer *m_pollingTimer = nullptr;
131		int m_pollingIndex = 0;
132		bool m_initialPollDone = false; // T-066: initial poll on first IDLE start
133		// Debounce timer for IDLE expunge events (avoid N× fetchFlags for bulk deletes)
134		QTimer *m_expungeDebounceTimer = nullptr;
135		QThreadPool m_flagMembershipPool;
136		std::shared_ptr<std::atomic_bool> m_flagMembershipCancelled;
137		quint64 m_flagMembershipSequence = 0;
138		std::function<QHash<qint64, quint32>(qint64)> m_visibleIndexedFlags;
139		QList<QPair<qint64, quint32>> m_changedSinceFlags;
140		};
141