d4708
/
qBittorrent
mirror of https://github.com/d47081/qBittorrent.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Follow project coding style. Issue #2192.

adaptive-webui-19844
sledgehammer999 10 years ago
parent
dcf5d4d0ee
commit
70985480d6
2 changed files with 451 additions and 379 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 610
      src/torrentpersistentdata.cpp
  2. 220
      src/torrentpersistentdata.h

610
src/torrentpersistentdata.cpp
Unescape View File

@ -46,392 +46,462 @@ QHash<QString, bool> HiddenData::data = QHash<QString, bool>();
unsigned int HiddenData::metadata_counter = 0; unsigned int HiddenData::metadata_counter = 0;
TorrentPersistentData* TorrentPersistentData::m_instance = 0; TorrentPersistentData* TorrentPersistentData::m_instance = 0;
bool TorrentTempData::hasTempData(const QString &hash) { TorrentTempData::TorrentData::TorrentData()
return data.contains(hash); : sequential(false)
, seed(false)
, add_paused(Preferences::instance()->addTorrentsInPause())
{
} }
void TorrentTempData::deleteTempData(const QString &hash) { TorrentTempData::TorrentMoveState::TorrentMoveState(QString oldPath, QString newPath)
data.remove(hash); : oldPath(oldPath)
, newPath(newPath)
{
} }
void TorrentTempData::setFilesPriority(const QString &hash, const std::vector<int> &pp) { bool TorrentTempData::hasTempData(const QString &hash)
data[hash].files_priority = pp; {
return data.contains(hash);
} }
void TorrentTempData::setFilesPath(const QString &hash, const QStringList &path_list) { void TorrentTempData::deleteTempData(const QString &hash)
data[hash].path_list = path_list; {
data.remove(hash);
} }
void TorrentTempData::setSavePath(const QString &hash, const QString &save_path) { void TorrentTempData::setFilesPriority(const QString &hash, const std::vector<int> &pp)
data[hash].save_path = save_path; {
data[hash].files_priority = pp;
} }
void TorrentTempData::setLabel(const QString &hash, const QString &label) { void TorrentTempData::setFilesPath(const QString &hash, const QStringList &path_list)
data[hash].label = label; {
data[hash].path_list = path_list;
} }
void TorrentTempData::setSequential(const QString &hash, const bool &sequential) { void TorrentTempData::setSavePath(const QString &hash, const QString &save_path)
data[hash].sequential = sequential; {
data[hash].save_path = save_path;
}
void TorrentTempData::setLabel(const QString &hash, const QString &label)
{
data[hash].label = label;
}
void TorrentTempData::setSequential(const QString &hash, const bool &sequential)
{
data[hash].sequential = sequential;
} }
bool TorrentTempData::isSequential(const QString &hash) { bool TorrentTempData::isSequential(const QString &hash)
return data.value(hash).sequential; {
return data.value(hash).sequential;
} }
void TorrentTempData::setSeedingMode(const QString &hash, const bool &seed) { void TorrentTempData::setSeedingMode(const QString &hash, const bool &seed)
data[hash].seed = seed; {
data[hash].seed = seed;
} }
bool TorrentTempData::isSeedingMode(const QString &hash) { bool TorrentTempData::isSeedingMode(const QString &hash)
return data.value(hash).seed; {
return data.value(hash).seed;
} }
QString TorrentTempData::getSavePath(const QString &hash) { QString TorrentTempData::getSavePath(const QString &hash)
return data.value(hash).save_path; {
return data.value(hash).save_path;
} }
QStringList TorrentTempData::getFilesPath(const QString &hash) { QStringList TorrentTempData::getFilesPath(const QString &hash)
return data.value(hash).path_list; {
return data.value(hash).path_list;
} }
QString TorrentTempData::getLabel(const QString &hash) { QString TorrentTempData::getLabel(const QString &hash)
return data.value(hash).label; {
return data.value(hash).label;
} }
void TorrentTempData::getFilesPriority(const QString &hash, std::vector<int> &fp) { void TorrentTempData::getFilesPriority(const QString &hash, std::vector<int> &fp)
fp = data.value(hash).files_priority; {
fp = data.value(hash).files_priority;
} }
bool TorrentTempData::isMoveInProgress(const QString &hash) { bool TorrentTempData::isMoveInProgress(const QString &hash)
return torrentMoveStates.find(hash) != torrentMoveStates.end(); {
return torrentMoveStates.find(hash) != torrentMoveStates.end();
} }
void TorrentTempData::enqueueMove(const QString &hash, const QString &queuedPath) { void TorrentTempData::enqueueMove(const QString &hash, const QString &queuedPath)
QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash); {
if (i == torrentMoveStates.end()) { QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
Q_ASSERT(false); if (i == torrentMoveStates.end()) {
return; Q_ASSERT(false);
} return;
i->queuedPath = queuedPath; }
i->queuedPath = queuedPath;
} }
void TorrentTempData::startMove(const QString &hash, const QString &oldPath, const QString& newPath) { void TorrentTempData::startMove(const QString &hash, const QString &oldPath, const QString& newPath)
QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash); {
if (i != torrentMoveStates.end()) { QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
Q_ASSERT(false); if (i != torrentMoveStates.end()) {
return; Q_ASSERT(false);
} return;
}
torrentMoveStates.insert(hash, TorrentMoveState(oldPath, newPath)); torrentMoveStates.insert(hash, TorrentMoveState(oldPath, newPath));
} }
void TorrentTempData::finishMove(const QString &hash) { void TorrentTempData::finishMove(const QString &hash)
QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash); {
if (i == torrentMoveStates.end()) { QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
Q_ASSERT(false); if (i == torrentMoveStates.end()) {
return; Q_ASSERT(false);
} return;
torrentMoveStates.erase(i); }
torrentMoveStates.erase(i);
} }
QString TorrentTempData::getOldPath(const QString &hash) { QString TorrentTempData::getOldPath(const QString &hash)
QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash); {
if (i == torrentMoveStates.end()) { QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
Q_ASSERT(false); if (i == torrentMoveStates.end()) {
return QString(); Q_ASSERT(false);
} return QString();
return i->oldPath; }
return i->oldPath;
} }
QString TorrentTempData::getNewPath(const QString &hash) { QString TorrentTempData::getNewPath(const QString &hash)
QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash); {
if (i == torrentMoveStates.end()) { QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
Q_ASSERT(false); if (i == torrentMoveStates.end()) {
return QString(); Q_ASSERT(false);
} return QString();
return i->newPath; }
return i->newPath;
} }
QString TorrentTempData::getQueuedPath(const QString &hash) { QString TorrentTempData::getQueuedPath(const QString &hash)
QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash); {
if (i == torrentMoveStates.end()) { QHash<QString, TorrentMoveState>::iterator i = torrentMoveStates.find(hash);
Q_ASSERT(false); if (i == torrentMoveStates.end()) {
return QString(); Q_ASSERT(false);
} return QString();
return i->queuedPath; }
return i->queuedPath;
} }
void TorrentTempData::setAddPaused(const QString &hash, const bool &paused) { void TorrentTempData::setAddPaused(const QString &hash, const bool &paused)
data[hash].add_paused = paused; {
data[hash].add_paused = paused;
} }
bool TorrentTempData::isAddPaused(const QString &hash) { bool TorrentTempData::isAddPaused(const QString &hash)
return data.value(hash).add_paused; {
return data.value(hash).add_paused;
} }
void HiddenData::addData(const QString &hash) { void HiddenData::addData(const QString &hash)
data[hash] = false; {
data[hash] = false;
} }
bool HiddenData::hasData(const QString &hash) { bool HiddenData::hasData(const QString &hash)
return data.contains(hash); {
return data.contains(hash);
} }
void HiddenData::deleteData(const QString &hash) { void HiddenData::deleteData(const QString &hash)
if (data.value(hash, false)) {
metadata_counter--; if (data.value(hash, false))
data.remove(hash); metadata_counter--;
data.remove(hash);
} }
int HiddenData::getSize() { int HiddenData::getSize()
return data.size(); {
return data.size();
} }
int HiddenData::getDownloadingSize() { int HiddenData::getDownloadingSize()
return data.size() - metadata_counter; {
return data.size() - metadata_counter;
} }
void HiddenData::gotMetadata(const QString &hash) { void HiddenData::gotMetadata(const QString &hash)
if (!data.contains(hash)) {
return; if (!data.contains(hash))
data[hash] = true; return;
metadata_counter++; data[hash] = true;
metadata_counter++;
} }
TorrentPersistentData::TorrentPersistentData() TorrentPersistentData::TorrentPersistentData()
: all_data(QIniSettings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume")).value("torrents").toHash()) : all_data(QIniSettings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume")).value("torrents").toHash())
, dirty(false) , dirty(false)
{ {
connect(&timer, SIGNAL(timeout()), SLOT(saveImpl())); connect(&timer, SIGNAL(timeout()), SLOT(saveImpl()));
m_instance = this; m_instance = this;
} }
TorrentPersistentData::~TorrentPersistentData() { TorrentPersistentData::~TorrentPersistentData()
save(); {
m_instance = 0; save();
m_instance = 0;
} }
void TorrentPersistentData::save() { void TorrentPersistentData::save()
if (dirty) {
saveImpl(); if (dirty)
saveImpl();
} }
TorrentPersistentData& TorrentPersistentData::instance() TorrentPersistentData& TorrentPersistentData::instance()
{ {
Q_ASSERT(m_instance); Q_ASSERT(m_instance);
return *m_instance; return *m_instance;
}
bool TorrentPersistentData::isKnownTorrent(QString hash)
{
return all_data.contains(hash);
} }
bool TorrentPersistentData::isKnownTorrent(QString hash) { QStringList TorrentPersistentData::knownTorrents()
return all_data.contains(hash); {
return all_data.keys();
}
void TorrentPersistentData::setRatioLimit(const QString &hash, const qreal &ratio)
{
QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["max_ratio"] = ratio;
all_data[hash] = data;
markDirty();
} }
QStringList TorrentPersistentData::knownTorrents() { qreal TorrentPersistentData::getRatioLimit(const QString &hash)
return all_data.keys(); {
const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("max_ratio", USE_GLOBAL_RATIO).toReal();
} }
void TorrentPersistentData::setRatioLimit(const QString &hash, const qreal &ratio) { bool TorrentPersistentData::hasPerTorrentRatioLimit()
QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
data["max_ratio"] = ratio; QHash<QString, QVariant>::ConstIterator it = all_data.constBegin();
all_data[hash] = data; QHash<QString, QVariant>::ConstIterator itend = all_data.constEnd();
markDirty(); for (; it != itend; ++it)
if (it.value().toHash().value("max_ratio", USE_GLOBAL_RATIO).toReal() >= 0)
return true;
return false;
} }
qreal TorrentPersistentData::getRatioLimit(const QString &hash) { void TorrentPersistentData::setAddedDate(const QString &hash, const QDateTime &time)
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
return data.value("max_ratio", USE_GLOBAL_RATIO).toReal(); QHash<QString, QVariant> data = all_data.value(hash).toHash();
if (!data.contains("add_date")) {
data["add_date"] = time;
all_data[hash] = data;
markDirty();
}
} }
bool TorrentPersistentData::hasPerTorrentRatioLimit() { QDateTime TorrentPersistentData::getAddedDate(const QString &hash)
QHash<QString, QVariant>::ConstIterator it = all_data.constBegin(); {
QHash<QString, QVariant>::ConstIterator itend = all_data.constEnd(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
for ( ; it != itend; ++it) { QDateTime dt = data.value("add_date").toDateTime();
if (it.value().toHash().value("max_ratio", USE_GLOBAL_RATIO).toReal() >= 0) { if (!dt.isValid()) {
return true; setAddedDate(hash, QDateTime::currentDateTime());
dt = QDateTime::currentDateTime();
} }
} return dt;
return false;
} }
void TorrentPersistentData::setAddedDate(const QString &hash, const QDateTime &time) { void TorrentPersistentData::setErrorState(const QString &hash, const bool has_error)
QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
if (!data.contains("add_date")) { QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["add_date"] = time; data["has_error"] = has_error;
all_data[hash] = data; all_data[hash] = data;
markDirty(); markDirty();
}
} }
QDateTime TorrentPersistentData::getAddedDate(const QString &hash) { bool TorrentPersistentData::hasError(const QString &hash)
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
QDateTime dt = data.value("add_date").toDateTime(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
if (!dt.isValid()) { return data.value("has_error", false).toBool();
setAddedDate(hash, QDateTime::currentDateTime()); }
dt = QDateTime::currentDateTime();
} QDateTime TorrentPersistentData::getSeedDate(const QString &hash)
return dt; {
const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("seed_date").toDateTime();
}
void TorrentPersistentData::deletePersistentData(const QString &hash)
{
if (all_data.contains(hash)) {
all_data.remove(hash);
markDirty();
}
} }
void TorrentPersistentData::setErrorState(const QString &hash, const bool has_error) { void TorrentPersistentData::saveTorrentPersistentData(const QTorrentHandle &h, const QString &save_path, const bool is_magnet)
QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
data["has_error"] = has_error; Q_ASSERT(h.is_valid());
all_data[hash] = data; qDebug("Saving persistent data for %s", qPrintable(h.hash()));
markDirty(); // Save persistent data
QHash<QString, QVariant> data = all_data.value(h.hash()).toHash();
data["is_magnet"] = is_magnet;
if (is_magnet)
data["magnet_uri"] = misc::toQString(make_magnet_uri(h));
data["seed"] = h.is_seed();
data["priority"] = h.queue_position();
if (save_path.isEmpty()) {
qDebug("TorrentPersistantData: save path is %s", qPrintable(h.save_path()));
data["save_path"] = h.save_path();
}
else {
qDebug("TorrentPersistantData: overriding save path is %s", qPrintable(save_path));
data["save_path"] = save_path; // Override torrent save path (e.g. because it is a temp dir)
}
// Label
data["label"] = TorrentTempData::getLabel(h.hash());
// Save data
all_data[h.hash()] = data;
markDirty();
qDebug("TorrentPersistentData: Saving save_path %s, hash: %s", qPrintable(h.save_path()), qPrintable(h.hash()));
// Set Added date
setAddedDate(h.hash(), QDateTime::currentDateTime());
// Finally, remove temp data
TorrentTempData::deleteTempData(h.hash());
} }
bool TorrentPersistentData::hasError(const QString &hash) { void TorrentPersistentData::saveSavePath(const QString &hash, const QString &save_path)
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
return data.value("has_error", false).toBool(); Q_ASSERT(!hash.isEmpty());
qDebug("TorrentPersistentData::saveSavePath(%s)", qPrintable(save_path));
QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["save_path"] = save_path;
all_data[hash] = data;
markDirty();
qDebug("TorrentPersistentData: Saving save_path: %s, hash: %s", qPrintable(save_path), qPrintable(hash));
} }
QDateTime TorrentPersistentData::getSeedDate(const QString &hash) { void TorrentPersistentData::saveLabel(const QString &hash, const QString &label)
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
return data.value("seed_date").toDateTime(); Q_ASSERT(!hash.isEmpty());
QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["label"] = label;
all_data[hash] = data;
markDirty();
} }
void TorrentPersistentData::deletePersistentData(const QString &hash) { void TorrentPersistentData::saveName(const QString &hash, const QString &name)
if (all_data.contains(hash)) { {
all_data.remove(hash); Q_ASSERT(!hash.isEmpty());
QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["name"] = name;
all_data[hash] = data;
markDirty(); markDirty();
} }
}
void TorrentPersistentData::savePriority(const QTorrentHandle &h)
void TorrentPersistentData::saveTorrentPersistentData(const QTorrentHandle &h, const QString &save_path, const bool is_magnet) { {
Q_ASSERT(h.is_valid()); QHash<QString, QVariant> data = all_data[h.hash()].toHash();
qDebug("Saving persistent data for %s", qPrintable(h.hash())); data["priority"] = h.queue_position();
// Save persistent data
QHash<QString, QVariant> data = all_data.value(h.hash()).toHash();
data["is_magnet"] = is_magnet;
if (is_magnet) {
data["magnet_uri"] = misc::toQString(make_magnet_uri(h));
}
data["seed"] = h.is_seed();
data["priority"] = h.queue_position();
if (save_path.isEmpty()) {
qDebug("TorrentPersistantData: save path is %s", qPrintable(h.save_path()));
data["save_path"] = h.save_path();
} else {
qDebug("TorrentPersistantData: overriding save path is %s", qPrintable(save_path));
data["save_path"] = save_path; // Override torrent save path (e.g. because it is a temp dir)
}
// Label
data["label"] = TorrentTempData::getLabel(h.hash());
// Save data
all_data[h.hash()] = data;
markDirty();
qDebug("TorrentPersistentData: Saving save_path %s, hash: %s", qPrintable(h.save_path()), qPrintable(h.hash()));
// Set Added date
setAddedDate(h.hash(), QDateTime::currentDateTime());
// Finally, remove temp data
TorrentTempData::deleteTempData(h.hash());
}
void TorrentPersistentData::saveSavePath(const QString &hash, const QString &save_path) {
Q_ASSERT(!hash.isEmpty());
qDebug("TorrentPersistentData::saveSavePath(%s)", qPrintable(save_path));
QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["save_path"] = save_path;
all_data[hash] = data;
markDirty();
qDebug("TorrentPersistentData: Saving save_path: %s, hash: %s", qPrintable(save_path), qPrintable(hash));
}
void TorrentPersistentData::saveLabel(const QString &hash, const QString &label) {
Q_ASSERT(!hash.isEmpty());
QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["label"] = label;
all_data[hash] = data;
markDirty();
}
void TorrentPersistentData::saveName(const QString &hash, const QString &name) {
Q_ASSERT(!hash.isEmpty());
QHash<QString, QVariant> data = all_data.value(hash).toHash();
data["name"] = name;
all_data[hash] = data;
markDirty();
}
void TorrentPersistentData::savePriority(const QTorrentHandle &h) {
QHash<QString, QVariant> data = all_data[h.hash()].toHash();
data["priority"] = h.queue_position();
all_data[h.hash()] = data;
markDirty();
}
void TorrentPersistentData::savePriority(const QString &hash, const int &queue_pos) {
QHash<QString, QVariant> data = all_data[hash].toHash();
data["priority"] = queue_pos;
all_data[hash] = data;
markDirty();
}
void TorrentPersistentData::saveSeedStatus(const QTorrentHandle &h) {
QHash<QString, QVariant> data = all_data[h.hash()].toHash();
bool was_seed = data.value("seed", false).toBool();
if (was_seed != h.is_seed()) {
data["seed"] = !was_seed;
all_data[h.hash()] = data; all_data[h.hash()] = data;
markDirty(); markDirty();
}
} }
void TorrentPersistentData::saveSeedStatus(const QString &hash, const bool seedStatus) { void TorrentPersistentData::savePriority(const QString &hash, const int &queue_pos)
QHash<QString, QVariant> data = all_data[hash].toHash(); {
data["seed"] = seedStatus; QHash<QString, QVariant> data = all_data[hash].toHash();
all_data[hash] = data; data["priority"] = queue_pos;
markDirty(); all_data[hash] = data;
markDirty();
}
void TorrentPersistentData::saveSeedStatus(const QTorrentHandle &h)
{
QHash<QString, QVariant> data = all_data[h.hash()].toHash();
bool was_seed = data.value("seed", false).toBool();
if (was_seed != h.is_seed()) {
data["seed"] = !was_seed;
all_data[h.hash()] = data;
markDirty();
}
}
void TorrentPersistentData::saveSeedStatus(const QString &hash, const bool seedStatus)
{
QHash<QString, QVariant> data = all_data[hash].toHash();
data["seed"] = seedStatus;
all_data[hash] = data;
markDirty();
} }
QString TorrentPersistentData::getSavePath(const QString &hash) { QString TorrentPersistentData::getSavePath(const QString &hash)
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
//qDebug("TorrentPersistentData: getSavePath %s", data["save_path"].toString().toLocal8Bit().data()); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("save_path").toString(); //qDebug("TorrentPersistentData: getSavePath %s", data["save_path"].toString().toLocal8Bit().data());
return data.value("save_path").toString();
} }
QString TorrentPersistentData::getLabel(const QString &hash) { QString TorrentPersistentData::getLabel(const QString &hash)
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
return data.value("label", "").toString(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("label", "").toString();
} }
QString TorrentPersistentData::getName(const QString &hash) { QString TorrentPersistentData::getName(const QString &hash)
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
return data.value("name", "").toString(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("name", "").toString();
} }
int TorrentPersistentData::getPriority(const QString &hash) { int TorrentPersistentData::getPriority(const QString &hash)
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
return data.value("priority", -1).toInt(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("priority", -1).toInt();
} }
bool TorrentPersistentData::isSeed(const QString &hash) { bool TorrentPersistentData::isSeed(const QString &hash)
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
return data.value("seed", false).toBool(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("seed", false).toBool();
} }
bool TorrentPersistentData::isMagnet(const QString &hash) { bool TorrentPersistentData::isMagnet(const QString &hash)
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
return data.value("is_magnet", false).toBool(); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("is_magnet", false).toBool();
} }
QString TorrentPersistentData::getMagnetUri(const QString &hash) { QString TorrentPersistentData::getMagnetUri(const QString &hash)
const QHash<QString, QVariant> data = all_data.value(hash).toHash(); {
Q_ASSERT(data.value("is_magnet", false).toBool()); const QHash<QString, QVariant> data = all_data.value(hash).toHash();
return data.value("magnet_uri").toString(); Q_ASSERT(data.value("is_magnet", false).toBool());
return data.value("magnet_uri").toString();
} }
void TorrentPersistentData::markDirty() { void TorrentPersistentData::markDirty()
if (!dirty) { {
dirty = true; if (!dirty) {
timer.start(1000); dirty = true;
} timer.start(1000);
}
} }
void TorrentPersistentData::saveImpl() { void TorrentPersistentData::saveImpl()
Q_ASSERT(dirty); {
Q_ASSERT(dirty);
QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume")); QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
settings.setValue("torrents", all_data); settings.setValue("torrents", all_data);
dirty = false; dirty = false;
timer.stop(); timer.stop();
} }

220
src/torrentpersistentdata.h
Unescape View File

@ -44,136 +44,138 @@ QT_END_NAMESPACE
class QTorrentHandle; class QTorrentHandle;
class TorrentTempData { class TorrentTempData
// This class stores strings w/o modifying separators {
// This class stores strings w/o modifying separators
public: public:
static bool hasTempData(const QString &hash); static bool hasTempData(const QString &hash);
static void deleteTempData(const QString &hash); static void deleteTempData(const QString &hash);
static void setFilesPriority(const QString &hash, const std::vector<int> &pp); static void setFilesPriority(const QString &hash, const std::vector<int> &pp);
static void setFilesPath(const QString &hash, const QStringList &path_list); static void setFilesPath(const QString &hash, const QStringList &path_list);
static void setSavePath(const QString &hash, const QString &save_path); static void setSavePath(const QString &hash, const QString &save_path);
static void setLabel(const QString &hash, const QString &label); static void setLabel(const QString &hash, const QString &label);
static void setSequential(const QString &hash, const bool &sequential); static void setSequential(const QString &hash, const bool &sequential);
static bool isSequential(const QString &hash); static bool isSequential(const QString &hash);
static void setSeedingMode(const QString &hash, const bool &seed); static void setSeedingMode(const QString &hash, const bool &seed);
static bool isSeedingMode(const QString &hash); static bool isSeedingMode(const QString &hash);
static QString getSavePath(const QString &hash); static QString getSavePath(const QString &hash);
static QStringList getFilesPath(const QString &hash); static QStringList getFilesPath(const QString &hash);
static QString getLabel(const QString &hash); static QString getLabel(const QString &hash);
static void getFilesPriority(const QString &hash, std::vector<int> &fp); static void getFilesPriority(const QString &hash, std::vector<int> &fp);
static bool isMoveInProgress(const QString &hash); static bool isMoveInProgress(const QString &hash);
static void enqueueMove(const QString &hash, const QString &queuedPath); static void enqueueMove(const QString &hash, const QString &queuedPath);
static void startMove(const QString &hash, const QString &oldPath, const QString& newPath); static void startMove(const QString &hash, const QString &oldPath, const QString& newPath);
static void finishMove(const QString &hash); static void finishMove(const QString &hash);
static QString getOldPath(const QString &hash); static QString getOldPath(const QString &hash);
static QString getNewPath(const QString &hash); static QString getNewPath(const QString &hash);
static QString getQueuedPath(const QString &hash); static QString getQueuedPath(const QString &hash);
static void setAddPaused(const QString &hash, const bool &paused); static void setAddPaused(const QString &hash, const bool &paused);
static bool isAddPaused(const QString &hash); static bool isAddPaused(const QString &hash);
private: private:
struct TorrentData { struct TorrentData
TorrentData(): sequential(false), seed(false), add_paused(Preferences::instance()->addTorrentsInPause()) {} {
std::vector<int> files_priority; TorrentData();
QStringList path_list; std::vector<int> files_priority;
QString save_path; QStringList path_list;
QString label; QString save_path;
bool sequential; QString label;
bool seed; bool sequential;
bool add_paused; bool seed;
}; bool add_paused;
};
struct TorrentMoveState {
TorrentMoveState(QString oldPath, QString newPath) struct TorrentMoveState
: oldPath(oldPath) {
, newPath(newPath) TorrentMoveState(QString oldPath, QString newPath);
{} // the moving occurs from oldPath to newPath
// queuedPath is where files should be moved to, when current moving is completed
// the moving occurs from oldPath to newPath QString oldPath;
// queuedPath is where files should be moved to, when current moving is completed QString newPath;
QString oldPath; QString queuedPath;
QString newPath; };
QString queuedPath;
}; static QHash<QString, TorrentData> data;
static QHash<QString, TorrentMoveState> torrentMoveStates;
static QHash<QString, TorrentData> data;
static QHash<QString, TorrentMoveState> torrentMoveStates;
}; };
class HiddenData { class HiddenData
{
public: public:
static void addData(const QString &hash); static void addData(const QString &hash);
static bool hasData(const QString &hash); static bool hasData(const QString &hash);
static void deleteData(const QString &hash); static void deleteData(const QString &hash);
static int getSize(); static int getSize();
static int getDownloadingSize(); static int getDownloadingSize();
static void gotMetadata(const QString &hash); static void gotMetadata(const QString &hash);
private: private:
static QHash<QString, bool> data; static QHash<QString, bool> data;
static unsigned int metadata_counter; static unsigned int metadata_counter;
}; };
class TorrentPersistentData : QObject { class TorrentPersistentData: QObject
Q_OBJECT {
Q_DISABLE_COPY(TorrentPersistentData) Q_OBJECT
// This class stores strings w/o modifying separators Q_DISABLE_COPY(TorrentPersistentData)
// This class stores strings w/o modifying separators
public: public:
enum RatioLimit { enum RatioLimit
USE_GLOBAL_RATIO = -2, {
NO_RATIO_LIMIT = -1 USE_GLOBAL_RATIO = -2,
}; NO_RATIO_LIMIT = -1
};
public: public:
TorrentPersistentData(); TorrentPersistentData();
~TorrentPersistentData(); ~TorrentPersistentData();
void save(); void save();
public: public:
static TorrentPersistentData& instance(); static TorrentPersistentData& instance();
bool isKnownTorrent(QString hash); bool isKnownTorrent(QString hash);
QStringList knownTorrents(); QStringList knownTorrents();
void setRatioLimit(const QString &hash, const qreal &ratio); void setRatioLimit(const QString &hash, const qreal &ratio);
qreal getRatioLimit(const QString &hash); qreal getRatioLimit(const QString &hash);
bool hasPerTorrentRatioLimit() ; bool hasPerTorrentRatioLimit();
void setAddedDate(const QString &hash, const QDateTime &time); void setAddedDate(const QString &hash, const QDateTime &time);
QDateTime getAddedDate(const QString &hash); QDateTime getAddedDate(const QString &hash);
void setErrorState(const QString &hash, const bool has_error); void setErrorState(const QString &hash, const bool has_error);
bool hasError(const QString &hash); bool hasError(const QString &hash);
QDateTime getSeedDate(const QString &hash); QDateTime getSeedDate(const QString &hash);
void deletePersistentData(const QString &hash); void deletePersistentData(const QString &hash);
void saveTorrentPersistentData(const QTorrentHandle &h, const QString &save_path = QString::null, const bool is_magnet = false); void saveTorrentPersistentData(const QTorrentHandle &h, const QString &save_path = QString::null, const bool is_magnet = false);
// Setters // Setters
void saveSavePath(const QString &hash, const QString &save_path); void saveSavePath(const QString &hash, const QString &save_path);
void saveLabel(const QString &hash, const QString &label); void saveLabel(const QString &hash, const QString &label);
void saveName(const QString &hash, const QString &name); void saveName(const QString &hash, const QString &name);
void savePriority(const QTorrentHandle &h); void savePriority(const QTorrentHandle &h);
void savePriority(const QString &hash, const int &queue_pos); void savePriority(const QString &hash, const int &queue_pos);
void saveSeedStatus(const QTorrentHandle &h); void saveSeedStatus(const QTorrentHandle &h);
void saveSeedStatus(const QString &hash, const bool seedStatus); void saveSeedStatus(const QString &hash, const bool seedStatus);
// Getters // Getters
QString getSavePath(const QString &hash); QString getSavePath(const QString &hash);
QString getLabel(const QString &hash); QString getLabel(const QString &hash);
QString getName(const QString &hash); QString getName(const QString &hash);
int getPriority(const QString &hash); int getPriority(const QString &hash);
bool isSeed(const QString &hash); bool isSeed(const QString &hash);
bool isMagnet(const QString &hash); bool isMagnet(const QString &hash);
QString getMagnetUri(const QString &hash); QString getMagnetUri(const QString &hash);
private: private:
void markDirty(); void markDirty();
private slots: private slots:
void saveImpl(); void saveImpl();
private: private:
QHash<QString, QVariant> all_data; QHash<QString, QVariant> all_data;
bool dirty; bool dirty;
QTimer timer; QTimer timer;
static TorrentPersistentData* m_instance; static TorrentPersistentData* m_instance;
}; };
#endif // TORRENTPERSISTENTDATA_H #endif // TORRENTPERSISTENTDATA_H

Write Preview
Loading…
Cancel
Save