squawk/core/delayManager/delaymanager.h

// 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 getOwnVCard();
    void getOwnInfo();
    void getVCard(const QString& jid);
    void getInfo(const QString& jid);
    void setOwnJid(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 disconnected();
    void ownVCardReceived(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