some more thinking about delay manager

core/CMakeLists.txt

@@ -34,3 +34,4 @@ add_subdirectory(handlers)
 add_subdirectory(storage)
 add_subdirectory(passwordStorageEngines)
 add_subdirectory(components)
+add_subdirectory(delayManager)

core/components/CMakeLists.txt

@@ -1,13 +1,11 @@
 set(SOURCE_FILES
     networkaccess.cpp
     clientcache.cpp
-    delaymanager.cpp
 )
 
 set(HEADER_FILES
     networkaccess.h
     clientcache.h
-    delaymanager.h
 )
 
 target_sources(squawk PRIVATE

core/components/delaymanager.cpp

@@ -1,136 +0,0 @@
-// 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/>.
-
-#include "delaymanager.h"
-
-Core::DelayManager::DelayManager(uint16_t mpj, QObject* parent) :
-    QObject(parent),
-    maxParallelJobs(mpj),
-    nextJobId(0),
-    scheduledJobs(),
-    runningJobs(),
-    pendingVCards(),
-    requestedVCards()
-{
-}
-
-Core::DelayManager::~DelayManager() {}
-
-void Core::DelayManager::requestInfo(const QString& jid) {
-    bool needToRequest = false;
-    std::pair<std::set<QString>::const_iterator, bool> result = pendingVCards.insert(jid);
-    if (result.second) {        //if there is a clear evidence that we have not alredy been asked to request a VCard - just request it
-        needToRequest = true;
-    } else {
-        std::map<QString, uint16_t>::const_iterator itr = requestedVCards.find(jid);
-        if (itr != requestedVCards.end()) {     //first check if the card is already requested, and if it is make sure we reply to user after we receive it
-            runningJobs[itr->second].first = TaskType::infoForUser;
-        } else {
-            needToRequest = true;
-            for (Job& job : scheduledJobs) {    //looks like we need to manually check all the scheduled job and find the one with that jid there
-                if (job.first == TaskType::cardInternal || job.first == TaskType::infoForUser) {    //to make sure we reply to user after we receive it
-                    QString* jobJid = static_cast<QString*>(job.second);
-                    if (*jobJid == jid) {
-                        needToRequest = false;
-                        job.first = TaskType::infoForUser;
-                        break;
-                    }
-                }
-            }
-            if (needToRequest) {
-                throw 8573; //something went terribly wrong here, the state is not correct;
-            }
-        }
-    }
-
-    if (needToRequest)
-        scheduleJob(TaskType::infoForUser, new QString(jid));
-}
-
-void Core::DelayManager::requestVCard(const QString& jid) {
-    std::pair<std::set<QString>::const_iterator, bool> result = pendingVCards.insert(jid);
-    if (result.second)
-        scheduleJob(TaskType::cardInternal, new QString(jid));
-}
-
-void Core::DelayManager::scheduleJob(Core::DelayManager::TaskType type, void* data) {
-    if (runningJobs.size() < maxParallelJobs) {
-        uint16_t currentJobId = nextJobId++;
-        runningJobs.emplace(currentJobId, std::make_pair(type, data));
-        switch (type) {
-            case TaskType::cardInternal:
-            case TaskType::infoForUser: {
-                QString* jid = static_cast<QString*>(data);
-                requestedVCards.emplace(*jid, currentJobId);
-                emit requestVCard(*jid);
-            }
-                break;
-        }
-    } else {
-        scheduledJobs.emplace_back(type, data);
-    }
-}
-
-void Core::DelayManager::executeJob(Core::DelayManager::Job job) {
-    uint16_t currentJobId = nextJobId++;
-    runningJobs.emplace(currentJobId, job);
-    switch (job.first) {
-        case TaskType::cardInternal:
-        case TaskType::infoForUser: {
-            QString* jid = static_cast<QString*>(job.second);
-            requestedVCards.emplace(*jid, currentJobId);
-            emit requestVCard(*jid);
-        }
-            break;
-    }
-}
-
-
-void Core::DelayManager::jobIsDone(uint16_t jobId) {
-    std::map<uint16_t, Job>::const_iterator itr = runningJobs.find(jobId);
-    if (itr == runningJobs.end()) {
-        throw 8574; //not supposed to happen, never
-    }
-    runningJobs.erase(itr);
-    if (scheduledJobs.size() > 0) {
-        Job job = scheduledJobs.front();
-        scheduledJobs.pop_front();
-        executeJob(job);
-    }
-}
-
-
-void Core::DelayManager::receivedVCard(const QString& jid, const Shared::VCard& card) {
-    std::map<QString, uint16_t>::const_iterator cardItr = requestedVCards.find(jid);
-    if (cardItr == requestedVCards.end()) {
-        throw 8575; //never supposed to happen, the state is not correct;
-    } else {
-        uint16_t jobId = cardItr->second;
-        requestedVCards.erase(cardItr);
-        pendingVCards.erase(jid);
-        const Job& job = runningJobs[jobId];
-        switch (job.first) {
-            case TaskType::cardInternal:
-                jobIsDone(jobId);
-                break;
-            case TaskType::infoForUser:
-                //all that stuff with further requesting
-                break;
-            default:
-                throw 8576;
-        }
-    }
-}

core/components/delaymanager.h

@@ -1,71 +0,0 @@
-// 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_H
-#define CORE_DELAYMANAGER_H
-
-#include <list>
-#include <set>
-
-#include <QObject>
-#include <QString>
-
-#include <shared/vcard.h>
-#include <shared/info.h>
-
-namespace Core {
-
-class DelayManager : public QObject
-{
-    Q_OBJECT
-
-    enum class TaskType {
-        cardInternal,
-        infoForUser
-    }
-public:
-    DelayManager(uint16_t maxParallelJobs = 5, QObject* parent = nullptr);
-    ~DelayManager();
-
-    void requestVCard(const QString& jid);
-    void requestInfo(const QString& jid);
-
-signals:
-    void requestVCard(const QString& jid);
-
-public slots:
-    void receivedVCard(const QString& jid, const Shared::VCard& card);
-
-private:
-    typedef std::pair<TaskType, void*> Job;
-
-    void scheduleJob(TaskType type, void* data);
-    void executeJob(Job job);
-    void jobIsDone(uint16_t jobId);
-
-private:
-    uint16_t maxParallelJobs;
-    uint16_t nextJobId;
-    std::list<Job> scheduledJobs;
-    std::map<uint16_t, Job> runningJobs;
-
-    std::set<QString> pendingVCards;
-    std::map<QString, uint16_t> requestedVCards;
-};
-
-}
-
-#endif // CORE_DELAYMANAGER_H

core/delayManager/CMakeLists.txt

@@ -0,0 +1,22 @@
+set(SOURCE_FILES
+    delaymanager.cpp
+    job.cpp
+    cardinternal.cpp
+    infoforuser.cpp
+    owncardinternal.cpp
+    owninfoforuser.cpp
+)
+
+set(HEADER_FILES
+    delaymanager.h
+    job.h
+    cardinternal.h
+    infoforuser.h
+    owncardinternal.h
+    owninfoforuser.h
+)
+
+target_sources(squawk PRIVATE
+    ${SOURCE_FILES}
+    ${HEADER_FILES}
+)

core/delayManager/cardinternal.cpp

@@ -0,0 +1,32 @@
+// 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/>.
+
+#include "cardinternal.h"
+
+Core::CardInternal::CardInternal(Job::Id p_id, const QString& p_jid) :
+    Job(p_id, Type::cardInternal),
+    jid(p_id)
+{}
+
+Core::CardInternal::CardInternal(Job::Id p_id, const QString& p_jid, Job::Type p_type) :
+    Job(p_id, p_type),
+    jid(p_id)
+{}
+
+Core::CardInternal::CardInternal(const Core::CardInternal& other) :
+    Job(other),
+    jid(other.jid)
+{}

core/delayManager/cardinternal.h

@@ -0,0 +1,41 @@
+// 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_CARDINTERNAL_H
+#define CORE_CARDINTERNAL_H
+
+
+#include <QString>
+
+#include "job.h"
+
+namespace Core {
+
+class CardInternal : public Job {
+protected:
+    CardInternal(Job::Id id, const QString& jid, Job::Type type);
+
+public:
+    CardInternal(Job::Id id, const QString& jid);
+    CardInternal(const CardInternal& other);
+
+    const QString jid;
+
+};
+
+}
+
+#endif // CORE_CARDINTERNAL_H

core/delayManager/delaymanager.cpp

@@ -0,0 +1,255 @@
+// 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/>.
+
+#include "delaymanager.h"
+
+#include "cardinternal.h"
+#include "infoforuser.h"
+#include "owncardinternal.h"
+#include "owninfoforuser.h"
+
+Core::DelayManager::DelayManager(Job::Id mpj, QObject* parent) :
+    QObject(parent),
+    maxParallelJobs(mpj),
+    nextJobId(1),
+    scheduledJobs(),
+    scheduledJobsById(scheduledJobs.get<id>()),
+    jobSequence(scheduledJobs.get<sequence>()),
+    runningJobs(),
+    ownVCardJobId(0),
+    ownInfoJobId(0),
+    scheduledVCards(),
+    requestedVCards(),
+    requestedBundles()
+{
+}
+
+Core::DelayManager::~DelayManager() {}
+
+Core::Job::Id Core::DelayManager::getNextJobId() {
+    Job::Id id = nextJobId++;
+    if (id == 0)
+        id = nextJobId++;
+
+    return id;
+}
+
+void Core::DelayManager::getInfo(const QString& jid) {
+    Job* job = nullptr;
+#ifdef WITH_OMEMO
+    std::map<QString, Job::Id>::const_iterator bitr = requestedBundles.find(jid);
+    if (bitr != requestedBundles.end())
+        job = runningJobs.at(bitr->second);
+    else
+#endif
+        job = getVCardJob(jid);
+
+    if (job != nullptr) {
+        if (job->getType() == Job::Type::cardInternal)
+            replaceJob(new InfoForUser(job->id, jid));
+    } else
+        scheduleJob(new InfoForUser(getNextJobId(), jid));
+}
+
+void Core::DelayManager::getOwnInfo() {
+    if (ownInfoJobId == 0) {
+        if (ownVCardJobId != 0)
+            replaceJob(new OwnInfoForUser(ownVCardJobId));
+        else
+            scheduleJob(new OwnInfoForUser(getNextJobId()));
+    }
+}
+
+void Core::DelayManager::getVCard(const QString& jid) {
+    Job* job = getVCardJob(jid);
+    if (job == nullptr)
+        scheduleJob(new CardInternal(getNextJobId(), jid));
+}
+
+void Core::DelayManager::getOwnVCard() {
+    if (ownInfoJobId == 0)
+        scheduleJob(new OwnCardInternal(getNextJobId()));
+}
+
+Core::Job* Core::DelayManager::getVCardJob(const QString& jid) {
+    Job* job = nullptr;
+    std::map<QString, Job::Id>::const_iterator sitr = scheduledVCards.find(jid);
+    if (sitr == scheduledVCards.end()) {
+        std::map<QString, Job::Id>::const_iterator ritr = requestedVCards.find(jid);
+        if (ritr != requestedVCards.end())
+            job = runningJobs.at(ritr->second);
+    } else {
+        job = *(scheduledJobsById.find(sitr->second));
+    }
+
+    return job;
+}
+void Core::DelayManager::preScheduleJob(Core::Job* job) {
+    switch (job->getType()) {
+        case Job::Type::cardInternal:
+            scheduledVCards.emplace(static_cast<CardInternal*>(job)->jid, job->id);
+            break;
+        case Job::Type::ownCardInternal:
+            ownVCardJobId = job->id;
+            break;
+        case Job::Type::infoForUser:
+            scheduledVCards.emplace(static_cast<InfoForUser*>(job)->jid, job->id);
+            break;
+        case Job::Type::ownInfoForUser:
+            ownVCardJobId = job->id;
+            ownInfoJobId = job->id;
+            break;
+    }
+}
+
+void Core::DelayManager::scheduleJob(Core::Job* job) {
+    preScheduleJob(job);
+    if (runningJobs.size() < maxParallelJobs) {
+        executeJob(job);
+    } else {
+        scheduledJobs.push_back(job);
+    }
+}
+
+void Core::DelayManager::preExecuteJob(Core::Job* job) {
+    switch (job->getType()) {
+        case Job::Type::cardInternal:
+        case Job::Type::infoForUser: {
+            CardInternal* cij = static_cast<CardInternal*>(job);
+            requestedVCards.emplace(cij->jid, job->id);
+            scheduledVCards.erase(cij->jid);
+        }
+            break;
+        case Job::Type::ownInfoForUser:
+        case Job::Type::ownCardInternal:
+            break;
+    }
+}
+
+void Core::DelayManager::executeJob(Core::Job* job) {
+    preExecuteJob(job);
+    runningJobs.emplace(job->id, job);
+    switch (job->getType()) {
+        case Job::Type::cardInternal:
+        case Job::Type::infoForUser:
+            emit requestVCard(static_cast<CardInternal*>(job)->jid);
+            break;
+        case Job::Type::ownInfoForUser:
+        case Job::Type::ownCardInternal:
+            emit requestOwnVCard();
+            break;
+    }
+}
+
+void Core::DelayManager::jobIsDone(Job::Id jobId) {
+    std::map<Job::Id, Job*>::const_iterator itr = runningJobs.find(jobId);
+    if (itr == runningJobs.end()) {
+        throw 8573; //not supposed to happen, ever
+    }
+    Job* job = itr->second;
+    delete job;
+    runningJobs.erase(itr);
+    if (scheduledJobs.size() > 0) {
+        Job* job = scheduledJobs.front();
+        scheduledJobs.pop_front();
+        executeJob(job);
+    }
+}
+
+void Core::DelayManager::replaceJob(Core::Job* job) {
+    preScheduleJob(job);
+    std::map<Job::Id, Job*>::iterator itr = runningJobs.find(job->id);
+    if (itr != runningJobs.end()) {
+        preExecuteJob(job);
+        delete itr->second;
+        itr->second = job;
+    } else {
+        StorageById::iterator sitr = scheduledJobsById.find(job->id);
+        if (sitr != scheduledJobsById.end()) {
+            delete *(sitr);
+            scheduledJobsById.replace(sitr, job);
+        } else {
+            throw 8574; //not supposed to happen, ever
+        }
+    }
+}
+
+void Core::DelayManager::receivedVCard(const QString& jid, const Shared::VCard& card) {
+    std::map<QString, Job::Id>::const_iterator cardItr = requestedVCards.find(jid);
+    if (cardItr == requestedVCards.end()) {
+        throw 8575; //never supposed to happen, the state is not correct;
+    } else {
+        Job::Id jobId = cardItr->second;
+        requestedVCards.erase(cardItr);
+        Job* job = runningJobs.at(jobId);
+        switch (job->getType()) {
+            case Job::Type::cardInternal:
+                jobIsDone(jobId);
+                emit receivedCard(jid, card);
+                break;
+            case Job::Type::infoForUser:
+#ifdef WITH_OMEMO
+                requestedBundles.emplace(jid, jobId);
+                //TODO save card!
+                emit requestBundles(jid);
+#else
+                {
+                    Shared::Info info(jid);
+                    info.turnIntoContact(card);
+                    emit receivedInfo(info);
+                }
+                jobIsDone(jobId);
+#endif
+                emit receivedCard(jid, card);
+                break;
+            default:
+                throw 8576;
+        }
+    }
+}
+
+void Core::DelayManager::ownVCardReceived(const Shared::VCard& card) {
+    Job::Id jobId = ownVCardJobId;
+    ownVCardJobId = 0;
+    Job* job = runningJobs.at(jobId);
+    switch (job->getType()) {
+        case Job::Type::ownCardInternal:
+            jobIsDone(jobId);
+            emit receivedOwnCard(card);
+            break;
+        case Job::Type::ownInfoForUser:
+#ifdef WITH_OMEMO
+            //requestedBundles.emplace(jid, jobId);
+            //TODO save card!
+            emit requestOwnBundle();
+#else
+            {
+                Shared::Info info("");
+                info.turnIntoOwnAccount(card);
+                emit receivedOwnInfo(info);
+            }
+            jobIsDone(jobId);
+#endif
+            emit receivedOwnCard(card);
+            break;
+        default:
+            throw 8576;
+    }
+}
+
+void Core::DelayManager::receivedBundles(const QString& jid) {
+
+}

core/delayManager/delaymanager.h

@@ -0,0 +1,116 @@
+// 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_H
+#define CORE_DELAYMANAGER_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 {
+
+class DelayManager : public QObject
+{
+    Q_OBJECT
+public:
+    DelayManager(Job::Id maxParallelJobs = 5, QObject* parent = nullptr);
+    ~DelayManager();
+
+    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 requestOwnBundle();
+    void receivedCard(const QString& jid, const Shared::VCard& info);
+    void receivedOwnCard(const Shared::VCard& info);
+    void receivedInfo(const Shared::Info& info);
+    void receivedOwnInfo(const Shared::Info& info);
+
+public slots:
+    void ownVCardReceived(const Shared::VCard& card);
+    void receivedVCard(const QString& jid, const Shared::VCard& card);
+    void receivedBundles(const QString& jid);
+
+private:
+    void preScheduleJob(Job* job);
+    void scheduleJob(Job* job);
+    void preExecuteJob(Job* job);
+    void executeJob(Job* job);
+    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;
+    std::map<QString, Job::Id> requestedBundles;
+};
+
+}
+
+#endif // CORE_DELAYMANAGER_H

core/delayManager/infoforuser.cpp

@@ -0,0 +1,26 @@
+// 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/>.
+
+#include "infoforuser.h"
+
+Core::InfoForUser::InfoForUser(Job::Id p_id, const QString& p_jid) :
+    CardInternal(p_id, p_jid, Type::infoForUser)
+{}
+
+Core::InfoForUser::InfoForUser(const Core::InfoForUser& other) :
+    CardInternal(other)
+{}
+

core/delayManager/infoforuser.h

@@ -0,0 +1,32 @@
+// 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_INFOFORUSER_H
+#define CORE_INFOFORUSER_H
+
+#include "cardinternal.h"
+
+namespace Core {
+
+class InfoForUser : public CardInternal {
+public:
+    InfoForUser(Job::Id id, const QString& jid);
+    InfoForUser(const InfoForUser& other);
+};
+
+}
+
+#endif // CORE_INFOFORUSER_H

core/delayManager/job.cpp

@@ -0,0 +1,32 @@
+// 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/>.
+
+#include "job.h"
+
+Core::Job::Job(Core::Job::Id p_id, Core::Job::Type p_type) :
+    id (p_id),
+    type (p_type) {}
+
+
+Core::Job::Job(const Core::Job& other) :
+    id(other.id),
+    type(other.type) {}
+
+Core::Job::~Job() {}
+
+Core::Job::Type Core::Job::getType() const {
+    return type;
+}

core/delayManager/job.h

@@ -0,0 +1,50 @@
+// 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_JOB_H
+#define CORE_DELAYMANAGER_JOB_H
+
+#include <stdint.h>
+
+namespace Core {
+
+class Job {
+public:
+    typedef uint16_t Id;
+
+    enum class Type {
+        cardInternal,
+        ownCardInternal,
+        infoForUser,
+        ownInfoForUser
+    };
+
+    Job(Id id, Type type);
+    Job(const Job& other);
+    virtual ~Job();
+
+    const Id id;
+
+public:
+    Type getType() const;
+
+protected:
+    Type type;
+};
+
+}
+
+#endif // CORE_DELAYMANAGER_JOB_H

core/delayManager/owncardinternal.cpp

@@ -0,0 +1,30 @@
+// 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/>.
+
+#include "owncardinternal.h"
+
+Core::OwnCardInternal::OwnCardInternal(Job::Id p_id) :
+    Job(p_id, Type::ownCardInternal)
+{}
+
+Core::OwnCardInternal::OwnCardInternal(Job::Id p_id, Job::Type p_type) :
+    Job(p_id, p_type)
+{}
+
+Core::OwnCardInternal::OwnCardInternal(const Core::OwnCardInternal& other) :
+    Job(other)
+{}
+

core/delayManager/owncardinternal.h

@@ -0,0 +1,35 @@
+// 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_OWNCARDINTERNAL_H
+#define CORE_OWNCARDINTERNAL_H
+
+#include "job.h"
+
+namespace Core {
+
+class OwnCardInternal : public Job {
+protected:
+    OwnCardInternal(Job::Id id, Job::Type type);
+
+public:
+    OwnCardInternal(Job::Id id);
+    OwnCardInternal(const OwnCardInternal& other);
+};
+
+}
+
+#endif // CORE_OWNCARDINTERNAL_H

core/delayManager/owninfoforuser.cpp

@@ -0,0 +1,25 @@
+// 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/>.
+
+#include "owninfoforuser.h"
+
+Core::OwnInfoForUser::OwnInfoForUser(Job::Id p_id) :
+    OwnCardInternal(p_id, Type::ownInfoForUser)
+{}
+
+Core::OwnInfoForUser::OwnInfoForUser(const Core::OwnInfoForUser& other) :
+    OwnCardInternal(other)
+{}

core/delayManager/owninfoforuser.h

@@ -0,0 +1,32 @@
+// 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_OWNINFOFORUSER_H
+#define CORE_OWNINFOFORUSER_H
+
+#include "owncardinternal.h"
+
+namespace Core {
+
+class OwnInfoForUser : public OwnCardInternal {
+public:
+    OwnInfoForUser(Job::Id id);
+    OwnInfoForUser(const OwnInfoForUser& other);
+};
+
+}
+
+#endif // CORE_OWNINFOFORUSER_H