DONT TAKE, BROKEN! first application of delay manager in code, reception of bundles

core/delayManager/manager.h

@@ -0,0 +1,129 @@
+// Squawk messenger. 
+// Copyright (C) 2019  Yury Gubich <blue@macaw.me>
+// 
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef CORE_DELAYMANAGER_MANAGER_H
+#define CORE_DELAYMANAGER_MANAGER_H
+
+#include <list>
+#include <set>
+
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/sequenced_index.hpp>
+#include <boost/multi_index/member.hpp>
+
+#include <QObject>
+#include <QString>
+
+#include <shared/vcard.h>
+#include <shared/info.h>
+
+#include "job.h"
+
+namespace Core {
+namespace DelayManager {
+
+class Manager : public QObject
+{
+    Q_OBJECT
+public:
+    Manager(const QString& ownJid, Job::Id maxParallelJobs = 5, QObject* parent = nullptr);
+    ~Manager();
+
+    void setOwnJid(const QString& jid);
+    bool isOwnVCardPending() const;
+
+public slots:
+    void getOwnVCard();
+    void getOwnInfo();
+    void getVCard(const QString& jid);
+    void getInfo(const QString& jid);
+
+signals:
+    void requestVCard(const QString& jid);
+    void requestOwnVCard();
+    void requestBundles(const QString& jid);
+    void requestOwnBundles();
+
+    void gotVCard(const QString& jid, const Shared::VCard& info);
+    void gotOwnVCard(const Shared::VCard& info);
+    void gotInfo(const Shared::Info& info);
+    void gotOwnInfo(const Shared::Info& info);
+
+public slots:
+    void disconnected();
+    void receivedOwnVCard(const Shared::VCard& card);
+    void receivedVCard(const QString& jid, const Shared::VCard& card);
+    void receivedBundles(const QString& jid, const std::list<Shared::KeyInfo>& keys);
+    void receivedOwnBundles(const std::list<Shared::KeyInfo>& keys);
+
+private:
+    void preScheduleJob(Job* job);
+    void scheduleJob(Job* job);
+    void preExecuteJob(Job* job);
+    void executeJob(Job* job);
+    void jobIsCanceled(Job* job, bool wasRunning);
+    void jobIsDone(Job::Id jobId);
+    Job::Id getNextJobId();
+    void replaceJob(Job* job);
+    Job* getVCardJob(const QString& jid);
+
+private:
+    struct id {};
+    struct sequence {};
+
+    typedef boost::multi_index_container<
+        Job*,
+        boost::multi_index::indexed_by<
+            boost::multi_index::sequenced<
+                boost::multi_index::tag<sequence>
+            >,
+            boost::multi_index::ordered_unique<
+                boost::multi_index::tag<id>,
+                boost::multi_index::member<
+                    Job,
+                    const Job::Id,
+                    &Job::id
+                >
+            >
+        >
+    > Storage;
+
+
+    typedef Storage::index<id>::type StorageById;
+    typedef Storage::index<sequence>::type StorageSequence;
+    Job::Id maxParallelJobs;
+    Job::Id nextJobId;
+
+    Storage scheduledJobs;
+    StorageById& scheduledJobsById;
+    StorageSequence& jobSequence;
+    std::map<Job::Id, Job*> runningJobs;
+
+    Job::Id ownVCardJobId;
+    Job::Id ownInfoJobId;
+    std::map<QString, Job::Id> scheduledVCards;
+    std::map<QString, Job::Id> requestedVCards;
+#ifdef WITH_OMEMO
+    std::map<QString, Job::Id> requestedBundles;
+#endif
+    QString ownJid;
+};
+
+}
+}
+
+#endif // CORE_DELAYMANAGER_MANAGER_H