1
0
forked from blue/squawk

some more thinking about delay manager

This commit is contained in:
Blue 2023-03-05 01:36:53 +03:00
parent 2d8f32c257
commit 99fd001292
Signed by untrusted user: blue
GPG Key ID: 9B203B252A63EE38
17 changed files with 729 additions and 209 deletions

View File

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

View File

@ -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

View File

@ -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;
}
}
}

View File

@ -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

View File

@ -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}
)

View File

@ -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)
{}

View File

@ -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

View File

@ -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) {
}

View File

@ -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

View File

@ -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)
{}

View File

@ -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

32
core/delayManager/job.cpp Normal file
View File

@ -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;
}

50
core/delayManager/job.h Normal file
View File

@ -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

View File

@ -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)
{}

View File

@ -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

View File

@ -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)
{}

View File

@ -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