Make 'TorrentPersistentData' similar to 'Preferences' class.

src/headlessloader.h

@@ -39,6 +39,7 @@
 #include "fs_utils.h"
 #include "misc.h"
 #include "logger.h"
+#include "torrentpersistentdata.h"
 
 class HeadlessLoader: public QObject {
   Q_OBJECT
@@ -69,6 +70,7 @@ public:
 public slots:
   void shutdownCleanUp() {
     QBtSession::drop();
+    TorrentPersistentData::drop();
     Preferences::drop();
     Logger::drop();
   }

src/mainwindow.cpp

@@ -63,6 +63,7 @@
 #include "preferences.h"
 #include "trackerlist.h"
 #include "peerlistwidget.h"
+#include "torrentpersistentdata.h"
 #include "transferlistfilterswidget.h"
 #include "propertieswidget.h"
 #include "statusbar.h"
@@ -505,6 +506,7 @@ void MainWindow::shutdownCleanUp()
     delete switchRSSShortcut;
     delete toolbarMenu;
     IconProvider::drop();
+    TorrentPersistentData::drop();
     Preferences::drop();
     Logger::drop();
     qDebug("Finished GUI destruction");
@@ -667,7 +669,7 @@ void MainWindow::balloonClicked()
 // called when a torrent has finished
 void MainWindow::finishedTorrent(const QTorrentHandle& h) const
 {
-    if (TorrentPersistentData::instance().isSeed(h.hash()))
+    if (TorrentPersistentData::instance()->isSeed(h.hash()))
         showNotificationBaloon(tr("Download completion"), tr("%1 has finished downloading.", "e.g: xxx.avi has finished downloading.").arg(h.name()));
 }
 

src/mainwindow.h

@@ -36,7 +36,6 @@
 #include <QPointer>
 #include "ui_mainwindow.h"
 #include "qtorrenthandle.h"
-#include "torrentpersistentdata.h"
 #include "statsdialog.h"
 
 class QBtSession;
@@ -217,7 +216,6 @@ private:
     bool has_python;
 #endif
     QMenu* toolbarMenu;
-    TorrentPersistentData persistentData;
 
 private slots:
     void on_actionSearch_engine_triggered();

src/qtlibtorrent/qbtsession.cpp

@@ -227,7 +227,7 @@ void QBtSession::processBigRatios() {
     if (h.is_seed()) {
       const QString hash = h.hash();
       const qreal ratio = getRealRatio(h.status(torrent_handle::query_accurate_download_counters));
-      qreal ratio_limit = TorrentPersistentData::instance().getRatioLimit(hash);
+      qreal ratio_limit = TorrentPersistentData::instance()->getRatioLimit(hash);
       if (ratio_limit == TorrentPersistentData::USE_GLOBAL_RATIO)
         ratio_limit = global_ratio_limit;
       if (ratio_limit == TorrentPersistentData::NO_RATIO_LIMIT)
@@ -830,7 +830,7 @@ void QBtSession::deleteTorrent(const QString &hash, bool delete_local_files) {
   foreach (const QString &file, files) {
     fsutils::forceRemove(torrentBackup.absoluteFilePath(file));
   }
-  TorrentPersistentData::instance().deletePersistentData(hash);
+  TorrentPersistentData::instance()->deletePersistentData(hash);
   TorrentTempData::deleteTempData(hash);
   HiddenData::deleteData(hash);
   // Remove tracker errors
@@ -981,7 +981,7 @@ QTorrentHandle QBtSession::addMagnetUri(QString magnet_uri, bool resumed, bool f
   }
   if (savePath.isEmpty())
     savePath = getSavePath(hash, false);
-  if (!defaultTempPath.isEmpty() && !TorrentPersistentData::instance().isSeed(hash)) {
+  if (!defaultTempPath.isEmpty() && !TorrentPersistentData::instance()->isSeed(hash)) {
     qDebug("addMagnetURI: Temp folder is enabled.");
     QString torrent_tmp_path = defaultTempPath;
     p.save_path = fsutils::toNativePath(torrent_tmp_path).toUtf8().constData();
@@ -1175,7 +1175,7 @@ QTorrentHandle QBtSession::addTorrent(QString path, bool fromScanDir, QString fr
   } else {
     savePath = getSavePath(hash, fromScanDir, path, imported);
   }
-  if (!imported && !defaultTempPath.isEmpty() && !TorrentPersistentData::instance().isSeed(hash)) {
+  if (!imported && !defaultTempPath.isEmpty() && !TorrentPersistentData::instance()->isSeed(hash)) {
     qDebug("addTorrent::Temp folder is enabled.");
     QString torrent_tmp_path = defaultTempPath;
     p.save_path = fsutils::toNativePath(torrent_tmp_path).toUtf8().constData();
@@ -1340,9 +1340,9 @@ void QBtSession::loadTorrentTempData(QTorrentHandle &h, QString savePath, bool m
   // Save persistent data for new torrent
   qDebug("Saving torrent persistant data");
   if (defaultTempPath.isEmpty())
-    TorrentPersistentData::instance().saveTorrentPersistentData(h, QString::null, magnet);
+    TorrentPersistentData::instance()->saveTorrentPersistentData(h, QString::null, magnet);
   else
-    TorrentPersistentData::instance().saveTorrentPersistentData(h, fsutils::fromNativePath(savePath), magnet);
+    TorrentPersistentData::instance()->saveTorrentPersistentData(h, fsutils::fromNativePath(savePath), magnet);
 }
 
 void QBtSession::mergeTorrents(QTorrentHandle& h_ex, const QString& magnet_uri)
@@ -1661,7 +1661,7 @@ void QBtSession::saveFastResumeData() {
       continue;
     try {
       if (isQueueingEnabled())
-        TorrentPersistentData::instance().savePriority(h);
+        TorrentPersistentData::instance()->savePriority(h);
       if (!h.has_metadata())
         continue;
       // Actually with should save fast resume data for paused files too
@@ -1850,7 +1850,7 @@ void QBtSession::appendqBextensionToTorrent(const QTorrentHandle &h, bool append
 void QBtSession::changeLabelInTorrentSavePath(const QTorrentHandle &h, QString old_label, QString new_label) {
   if (!h.is_valid()) return;
   if (!appendLabelToSavePath) return;
-  QString old_save_path = fsutils::fromNativePath(TorrentPersistentData::instance().getSavePath(h.hash()));
+  QString old_save_path = fsutils::fromNativePath(TorrentPersistentData::instance()->getSavePath(h.hash()));
   if (!old_save_path.startsWith(defaultSavePath)) return;
   QString new_save_path = fsutils::updateLabelInSavePath(defaultSavePath, old_save_path, old_label, new_label);
   if (new_save_path != old_save_path) {
@@ -1863,10 +1863,11 @@ void QBtSession::changeLabelInTorrentSavePath(const QTorrentHandle &h, QString o
 
 void QBtSession::appendLabelToTorrentSavePath(const QTorrentHandle& h) {
   if (!h.is_valid()) return;
-  const QString label = TorrentPersistentData::instance().getLabel(h.hash());
+  const TorrentPersistentData* const TorPersistent = TorrentPersistentData::instance();
+  const QString label = TorPersistent->getLabel(h.hash());
   if (label.isEmpty()) return;
   // Current save path
-  QString old_save_path = fsutils::fromNativePath(TorrentPersistentData::instance().getSavePath(h.hash()));
+  QString old_save_path = fsutils::fromNativePath(TorPersistent->getSavePath(h.hash()));
   QString new_save_path = fsutils::updateLabelInSavePath(defaultSavePath, old_save_path, "", label);
   if (old_save_path != new_save_path) {
     // Move storage
@@ -1992,20 +1993,20 @@ void QBtSession::setMaxRatioPerTorrent(const QString &hash, qreal ratio)
     ratio = MAX_RATIO;
   qDebug("* Set individual max ratio for torrent %s to %.1f.",
          qPrintable(hash), ratio);
-  TorrentPersistentData::instance().setRatioLimit(hash, ratio);
+  TorrentPersistentData::instance()->setRatioLimit(hash, ratio);
   updateRatioTimer();
 }
 
 void QBtSession::removeRatioPerTorrent(const QString &hash)
 {
   qDebug("* Remove individual max ratio for torrent %s.", qPrintable(hash));
-  TorrentPersistentData::instance().setRatioLimit(hash, TorrentPersistentData::USE_GLOBAL_RATIO);
+  TorrentPersistentData::instance()->setRatioLimit(hash, TorrentPersistentData::USE_GLOBAL_RATIO);
   updateRatioTimer();
 }
 
 qreal QBtSession::getMaxRatioPerTorrent(const QString &hash, bool *usesGlobalRatio) const
 {
-  qreal ratio_limit = TorrentPersistentData::instance().getRatioLimit(hash);
+  qreal ratio_limit = TorrentPersistentData::instance()->getRatioLimit(hash);
   if (ratio_limit == TorrentPersistentData::USE_GLOBAL_RATIO) {
     ratio_limit = global_ratio_limit;
     if (usesGlobalRatio)
@@ -2019,7 +2020,7 @@ qreal QBtSession::getMaxRatioPerTorrent(const QString &hash, bool *usesGlobalRat
 
 void QBtSession::updateRatioTimer()
 {
-  if (global_ratio_limit == -1 && !TorrentPersistentData::instance().hasPerTorrentRatioLimit()) {
+  if (global_ratio_limit == -1 && !TorrentPersistentData::instance()->hasPerTorrentRatioLimit()) {
     if (BigRatioTimer->isActive())
       BigRatioTimer->stop();
   } else if (!BigRatioTimer->isActive()) {
@@ -2099,7 +2100,7 @@ void QBtSession::sendNotificationEmail(const QTorrentHandle &h) {
   // Prepare mail content
   QString content = tr("Torrent name: %1").arg(h.name()) + "\n";
   content += tr("Torrent size: %1").arg(misc::friendlyUnit(status.total_wanted)) + "\n";
-  content += tr("Save path: %1").arg(TorrentPersistentData::instance().getSavePath(h.hash())) + "\n\n";
+  content += tr("Save path: %1").arg(TorrentPersistentData::instance()->getSavePath(h.hash())) + "\n\n";
   content += tr("The torrent was downloaded in %1.", "The torrent was downloaded in 1 hour and 20 seconds").arg(misc::userFriendlyDuration(status.active_time)) + "\n\n\n";
   content += tr("Thank you for using qBittorrent.") + "\n";
   // Send the notification email
@@ -2213,7 +2214,8 @@ void QBtSession::handleTorrentFinishedAlert(libtorrent::torrent_finished_alert*
     if (appendqBExtension)
       appendqBextensionToTorrent(h, false);
 
-    const bool was_already_seeded = TorrentPersistentData::instance().isSeed(hash);
+    TorrentPersistentData* const TorPersistent = TorrentPersistentData::instance();
+    const bool was_already_seeded = TorPersistent->isSeed(hash);
     qDebug("Was already seeded: %d", was_already_seeded);
     if (!was_already_seeded) {
       h.save_resume_data();
@@ -2256,7 +2258,7 @@ void QBtSession::handleTorrentFinishedAlert(libtorrent::torrent_finished_alert*
       }
       // Remember finished state
       qDebug("Saving seed status");
-      TorrentPersistentData::instance().saveSeedStatus(h);
+      TorPersistent->saveSeedStatus(h);
       // Recheck if the user asked to
       Preferences* const pref = Preferences::instance();
       if (pref->recheckTorrentsOnCompletion()) {
@@ -2418,7 +2420,7 @@ void QBtSession::handleStorageMovedAlert(libtorrent::storage_moved_alert* p) {
   }
   if (defaultTempPath.isEmpty() || !new_save_path.startsWith(defaultTempPath)) {
     qDebug("Storage has been moved, updating save path to %s", qPrintable(new_save_path));
-    TorrentPersistentData::instance().saveSavePath(h.hash(), new_save_path);
+    TorrentPersistentData::instance()->saveSavePath(h.hash(), new_save_path);
   }
   emit savePathChanged(h);
   //h.force_recheck();
@@ -2657,11 +2659,11 @@ void QBtSession::handleFastResumeRejectedAlert(libtorrent::fastresume_rejected_a
   QTorrentHandle h(p->handle);
   if (h.is_valid()) {
     qDebug("/!\\ Fast resume failed for %s, reason: %s", qPrintable(h.name()), p->message().c_str());
-    if (p->error.value() == 134 && TorrentPersistentData::instance().isSeed(h.hash()) && h.has_missing_files()) {
+    if (p->error.value() == 134 && TorrentPersistentData::instance()->isSeed(h.hash()) && h.has_missing_files()) {
       const QString hash = h.hash();
       // Mismatching file size (files were probably moved
       logger->addMessage(tr("File sizes mismatch for torrent %1, pausing it.").arg(h.name()));
-      TorrentPersistentData::instance().setErrorState(hash, true);
+      TorrentPersistentData::instance()->setErrorState(hash, true);
       pauseTorrent(hash);
     } else {
       logger->addMessage(tr("Fast resume data was rejected for torrent %1, checking again...").arg(h.name()), Log::CRITICAL);
@@ -2723,7 +2725,7 @@ void QBtSession::handleTorrentCheckedAlert(libtorrent::torrent_checked_alert* p)
     const QString hash = h.hash();
     qDebug("%s have just finished checking", qPrintable(hash));
     // Save seed status
-    TorrentPersistentData::instance().saveSeedStatus(h);
+    TorrentPersistentData::instance()->saveSeedStatus(h);
     // Move to temp directory if necessary
     if (!h.is_seed() && !defaultTempPath.isEmpty()) {
       // Check if directory is different
@@ -2846,7 +2848,7 @@ QString QBtSession::getSavePath(const QString &hash, bool fromScanDir, QString f
     }
     qDebug("getSavePath, got save_path from temp data: %s", qPrintable(savePath));
   } else {
-    savePath = fsutils::fromNativePath(TorrentPersistentData::instance().getSavePath(hash));
+    savePath = fsutils::fromNativePath(TorrentPersistentData::instance()->getSavePath(hash));
     qDebug("SavePath got from persistant data is %s", qPrintable(savePath));
     if (savePath.isEmpty()) {
       if (fromScanDir && m_scanFolders->downloadInTorrentFolder(filePath)) {
@@ -2856,7 +2858,7 @@ QString QBtSession::getSavePath(const QString &hash, bool fromScanDir, QString f
       }
     }
     if (!fromScanDir && appendLabelToSavePath) {
-      const QString label = TorrentPersistentData::instance().getLabel(hash);
+      const QString label = TorrentPersistentData::instance()->getLabel(hash);
       if (!label.isEmpty()) {
         qDebug("Torrent label is %s", qPrintable(label));
         savePath = fsutils::updateLabelInSavePath(defaultSavePath, savePath, "", label);
@@ -3011,7 +3013,8 @@ qreal QBtSession::getPayloadUploadRate() const {
 void QBtSession::startUpTorrents() {
   qDebug("Resuming unfinished torrents");
   const QDir torrentBackup(fsutils::BTBackupLocation());
-  const QStringList known_torrents = TorrentPersistentData::instance().knownTorrents();
+  const TorrentPersistentData* const TorPersistent = TorrentPersistentData::instance();
+  const QStringList known_torrents = TorPersistent->knownTorrents();
 
   // Safety measure because some people reported torrent loss since
   // we switch the v1.5 way of resuming torrents on startup
@@ -3032,7 +3035,7 @@ void QBtSession::startUpTorrents() {
   if (isQueueingEnabled()) {
     priority_queue<QPair<int, QString>, vector<QPair<int, QString> >, std::greater<QPair<int, QString> > > torrent_queue;
     foreach (const QString &hash, known_torrents) {
-      const int prio = TorrentPersistentData::instance().getPriority(hash);
+      const int prio = TorPersistent->getPriority(hash);
       torrent_queue.push(qMakePair(prio, hash));
     }
     qDebug("Priority_queue size: %ld", (long)torrent_queue.size());
@@ -3041,8 +3044,8 @@ void QBtSession::startUpTorrents() {
       const QString hash = torrent_queue.top().second;
       torrent_queue.pop();
       qDebug("Starting up torrent %s", qPrintable(hash));
-      if (TorrentPersistentData::instance().isMagnet(hash)) {
-        addMagnetUri(TorrentPersistentData::instance().getMagnetUri(hash), true);
+      if (TorPersistent->isMagnet(hash)) {
+        addMagnetUri(TorPersistent->getMagnetUri(hash), true);
       } else {
         addTorrent(torrentBackup.path()+"/"+hash+".torrent", false, QString(), true);
       }
@@ -3051,8 +3054,8 @@ void QBtSession::startUpTorrents() {
     // Resume downloads
     foreach (const QString &hash, known_torrents) {
       qDebug("Starting up torrent %s", qPrintable(hash));
-      if (TorrentPersistentData::instance().isMagnet(hash))
-        addMagnetUri(TorrentPersistentData::instance().getMagnetUri(hash), true);
+      if (TorPersistent->isMagnet(hash))
+        addMagnetUri(TorPersistent->getMagnetUri(hash), true);
       else
         addTorrent(torrentBackup.path()+"/"+hash+".torrent", false, QString(), true);
     }
@@ -3106,7 +3109,8 @@ void QBtSession::handleIPFilterError()
 }
 
 void QBtSession::recoverPersistentData(const QString &hash, const std::vector<char> &buf) {
-  if (TorrentPersistentData::instance().isKnownTorrent(hash) || TorrentTempData::hasTempData(hash) || buf.empty())
+  TorrentPersistentData* const TorPersistent = TorrentPersistentData::instance();
+  if (TorPersistent->isKnownTorrent(hash) || TorrentTempData::hasTempData(hash) || buf.empty())
     return;
 
   libtorrent::lazy_entry fast;
@@ -3123,20 +3127,21 @@ void QBtSession::recoverPersistentData(const QString &hash, const std::vector<ch
   int priority = fast.dict_find_int_value("qBt-queuePosition");
   bool seedStatus = fast.dict_find_int_value("qBt-seedStatus");
 
-  TorrentPersistentData::instance().saveSavePath(hash, savePath);
-  TorrentPersistentData::instance().setRatioLimit(hash, ratioLimit);
-  TorrentPersistentData::instance().setAddedDate(hash, addedDate);
-  TorrentPersistentData::instance().saveLabel(hash, label);
-  TorrentPersistentData::instance().savePriority(hash, priority);
-  TorrentPersistentData::instance().saveSeedStatus(hash, seedStatus);
+  TorPersistent->saveSavePath(hash, savePath);
+  TorPersistent->setRatioLimit(hash, ratioLimit);
+  TorPersistent->setAddedDate(hash, addedDate);
+  TorPersistent->saveLabel(hash, label);
+  TorPersistent->savePriority(hash, priority);
+  TorPersistent->saveSeedStatus(hash, seedStatus);
 }
 
 void QBtSession::backupPersistentData(const QString &hash, boost::shared_ptr<libtorrent::entry> data) {
-  (*data)["qBt-savePath"] = fsutils::fromNativePath(TorrentPersistentData::instance().getSavePath(hash)).toUtf8().constData();
-  (*data)["qBt-ratioLimit"] = QString::number(TorrentPersistentData::instance().getRatioLimit(hash)).toUtf8().constData();
-  (*data)["qBt-label"] = TorrentPersistentData::instance().getLabel(hash).toUtf8().constData();
-  (*data)["qBt-queuePosition"] = TorrentPersistentData::instance().getPriority(hash);
-  (*data)["qBt-seedStatus"] = (int)TorrentPersistentData::instance().isSeed(hash);
+  const TorrentPersistentData* const TorPersistent = TorrentPersistentData::instance();
+  (*data)["qBt-savePath"] = fsutils::fromNativePath(TorPersistent->getSavePath(hash)).toUtf8().constData();
+  (*data)["qBt-ratioLimit"] = QString::number(TorPersistent->getRatioLimit(hash)).toUtf8().constData();
+  (*data)["qBt-label"] = TorPersistent->getLabel(hash).toUtf8().constData();
+  (*data)["qBt-queuePosition"] = TorPersistent->getPriority(hash);
+  (*data)["qBt-seedStatus"] = (int)TorPersistent->isSeed(hash);
 }
 
 void QBtSession::unhideMagnet(const QString &hash) {
@@ -3191,7 +3196,7 @@ void QBtSession::unhideMagnet(const QString &hash) {
   }
 
   h.queue_position_bottom();
-  loadTorrentTempData(h, h.save_path(), !h.has_metadata()); //TempData are deleted by a call to TorrentPersistentData::instance().saveTorrentPersistentData()
+  loadTorrentTempData(h, h.save_path(), !h.has_metadata()); //TempData are deleted by a call to TorrentPersistentData::instance()->saveTorrentPersistentData()
   if (!add_paused)
     h.resume();
   h.move_storage(save_path);

src/qtlibtorrent/qtorrenthandle.cpp

@@ -86,7 +86,7 @@ QString QTorrentHandle::hash() const
 
 QString QTorrentHandle::name() const
 {
-    QString name = TorrentPersistentData::instance().getName(hash());
+    QString name = TorrentPersistentData::instance()->getName(hash());
     if (name.isEmpty()) {
 #if LIBTORRENT_VERSION_NUM < 10000
         name = misc::toQStringU(torrent_handle::name());
@@ -201,7 +201,7 @@ QString QTorrentHandle::save_path_parsed() const
         p = firstFileSavePath();
     }
     else {
-        p = fsutils::fromNativePath(TorrentPersistentData::instance().getSavePath(hash()));
+        p = fsutils::fromNativePath(TorrentPersistentData::instance()->getSavePath(hash()));
         if (p.isEmpty())
             p = save_path();
     }
@@ -386,7 +386,7 @@ bool QTorrentHandle::priv() const
 QString QTorrentHandle::firstFileSavePath() const
 {
     Q_ASSERT(has_metadata());
-    QString fsave_path = fsutils::fromNativePath(TorrentPersistentData::instance().getSavePath(hash()));
+    QString fsave_path = fsutils::fromNativePath(TorrentPersistentData::instance()->getSavePath(hash()));
     if (fsave_path.isEmpty())
         fsave_path = save_path();
     if (!fsave_path.endsWith("/"))
@@ -520,13 +520,14 @@ void QTorrentHandle::resume() const
         torrent_handle::clear_error();
 
     const QString torrent_hash = hash();
-    bool has_persistant_error = TorrentPersistentData::instance().hasError(torrent_hash);
-    TorrentPersistentData::instance().setErrorState(torrent_hash, false);
+    TorrentPersistentData* const TorPersistent = TorrentPersistentData::instance();
+    bool has_persistant_error = TorPersistent->hasError(torrent_hash);
+    TorPersistent->setErrorState(torrent_hash, false);
     bool temp_path_enabled = Preferences::instance()->isTempPathEnabled();
     if (has_persistant_error && temp_path_enabled) {
         // Torrent was supposed to be seeding, checking again in final destination
         qDebug("Resuming a torrent with error...");
-        const QString final_save_path = TorrentPersistentData::instance().getSavePath(torrent_hash);
+        const QString final_save_path = TorPersistent->getSavePath(torrent_hash);
         qDebug("Torrent final path is: %s", qPrintable(final_save_path));
         if (!final_save_path.isEmpty())
             move_storage(final_save_path);
@@ -691,7 +692,7 @@ void QTorrentHandle::prioritize_files(const vector<int> &files) const
     if (was_seed && !is_seed()) {
         qDebug() << "Torrent is no longer SEEDING";
         // Save seed status
-        TorrentPersistentData::instance().saveSeedStatus(*this);
+        TorrentPersistentData::instance()->saveSeedStatus(*this);
         // Move to temp folder if necessary
         const Preferences* const pref = Preferences::instance();
         if (pref->isTempPathEnabled()) {

src/qtlibtorrent/torrentmodel.cpp

@@ -84,9 +84,9 @@ QIcon get_error_icon() {
 TorrentModelItem::TorrentModelItem(const QTorrentHandle &h)
   : m_torrent(h)
   , m_lastStatus(h.status(torrent_handle::query_accurate_download_counters))
-  , m_addedTime(TorrentPersistentData::instance().getAddedDate(h.hash()))
-  , m_label(TorrentPersistentData::instance().getLabel(h.hash()))
-  , m_name(TorrentPersistentData::instance().getName(h.hash()))
+  , m_addedTime(TorrentPersistentData::instance()->getAddedDate(h.hash()))
+  , m_label(TorrentPersistentData::instance()->getLabel(h.hash()))
+  , m_name(TorrentPersistentData::instance()->getName(h.hash()))
   , m_hash(h.hash())
 {
   if (m_name.isEmpty())
@@ -202,14 +202,14 @@ bool TorrentModelItem::setData(int column, const QVariant &value, int role)
   switch(column) {
   case TR_NAME:
     m_name = value.toString();
-    TorrentPersistentData::instance().saveName(m_torrent.hash(), m_name);
+    TorrentPersistentData::instance()->saveName(m_torrent.hash(), m_name);
     return true;
   case TR_LABEL: {
     QString new_label = value.toString();
     if (m_label != new_label) {
       QString old_label = m_label;
       m_label = new_label;
-      TorrentPersistentData::instance().saveLabel(m_torrent.hash(), new_label);
+      TorrentPersistentData::instance()->saveLabel(m_torrent.hash(), new_label);
       emit labelChanged(old_label, new_label);
     }
     return true;

src/torrentpersistentdata.cpp

@@ -241,59 +241,89 @@ void HiddenData::gotMetadata(const QString &hash)
 }
 
 TorrentPersistentData::TorrentPersistentData()
-    : all_data(QIniSettings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume")).value("torrents").toHash())
+    : m_data(QIniSettings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume")).value("torrents").toHash())
     , dirty(false)
 {
-    connect(&timer, SIGNAL(timeout()), SLOT(saveImpl()));
-    m_instance = this;
+    timer.setSingleShot(true);
+    timer.setInterval(5*1000);
+    connect(&timer, SIGNAL(timeout()), SLOT(save()));
 }
 
 TorrentPersistentData::~TorrentPersistentData()
 {
     save();
-    m_instance = 0;
 }
 
 void TorrentPersistentData::save()
 {
-    if (dirty)
-        saveImpl();
+    if (!dirty)
+        return;
+
+    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
+    settings.setValue("torrents", m_data);
+    dirty = false;
+}
+
+const QVariant TorrentPersistentData::value(const QString &key, const QVariant &defaultValue) const {
+    QReadLocker locker(&lock);
+    return m_data.value(key, defaultValue);
+}
+
+void TorrentPersistentData::setValue(const QString &key, const QVariant &value) {
+    QWriteLocker locker(&lock);
+    if (m_data.value(key) == value)
+        return;
+    dirty = true;
+    timer.start();
+    m_data.insert(key, value);
 }
 
-TorrentPersistentData& TorrentPersistentData::instance()
+TorrentPersistentData* TorrentPersistentData::instance()
 {
-    Q_ASSERT(m_instance);
-    return *m_instance;
+    if (!m_instance)
+        m_instance = new TorrentPersistentData;
+
+    return m_instance;
+}
+
+void TorrentPersistentData::drop()
+{
+    if (m_instance) {
+        delete m_instance;
+        m_instance = 0;
+    }
 }
 
-bool TorrentPersistentData::isKnownTorrent(QString hash)
+bool TorrentPersistentData::isKnownTorrent(QString hash) const
 {
-    return all_data.contains(hash);
+    QReadLocker locker(&lock);
+    return m_data.contains(hash);
 }
 
-QStringList TorrentPersistentData::knownTorrents()
+QStringList TorrentPersistentData::knownTorrents() const
 {
-    return all_data.keys();
+    QReadLocker locker(&lock);
+    return m_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();
+    QHash<QString, QVariant> torrent = value(hash).toHash();
+    torrent["max_ratio"] = ratio;
+    setValue(hash, torrent);
 }
 
-qreal TorrentPersistentData::getRatioLimit(const QString &hash)
+qreal TorrentPersistentData::getRatioLimit(const QString &hash) const
 {
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("max_ratio", USE_GLOBAL_RATIO).toReal();
+    const QHash<QString, QVariant> torrent = value(hash).toHash();
+    return torrent.value("max_ratio", USE_GLOBAL_RATIO).toReal();
 }
 
-bool TorrentPersistentData::hasPerTorrentRatioLimit()
+bool TorrentPersistentData::hasPerTorrentRatioLimit() const
 {
-    QHash<QString, QVariant>::ConstIterator it = all_data.constBegin();
-    QHash<QString, QVariant>::ConstIterator itend = all_data.constEnd();
+    QReadLocker locker(&lock);
+    QHash<QString, QVariant>::ConstIterator it = m_data.constBegin();
+    QHash<QString, QVariant>::ConstIterator itend = m_data.constEnd();
     for (; it != itend; ++it)
         if (it.value().toHash().value("max_ratio", USE_GLOBAL_RATIO).toReal() >= 0)
             return true;
@@ -302,206 +332,181 @@ bool TorrentPersistentData::hasPerTorrentRatioLimit()
 
 void TorrentPersistentData::setAddedDate(const QString &hash, const QDateTime &time)
 {
-    QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    if (!data.contains("add_date")) {
-        data["add_date"] = time;
-        all_data[hash] = data;
-        markDirty();
+    QHash<QString, QVariant> torrent = value(hash).toHash();
+    if (!torrent.contains("add_date")) {
+        torrent["add_date"] = time;
+        setValue(hash, torrent);
     }
 }
 
-QDateTime TorrentPersistentData::getAddedDate(const QString &hash)
+QDateTime TorrentPersistentData::getAddedDate(const QString &hash) const
 {
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    QDateTime dt = data.value("add_date").toDateTime();
-    if (!dt.isValid()) {
-        setAddedDate(hash, QDateTime::currentDateTime());
+    const QHash<QString, QVariant> torrent = value(hash).toHash();
+    QDateTime dt = torrent.value("add_date").toDateTime();
+    if (!dt.isValid())
         dt = QDateTime::currentDateTime();
-    }
     return dt;
 }
 
 void TorrentPersistentData::setErrorState(const QString &hash, const bool has_error)
 {
-    QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    data["has_error"] = has_error;
-    all_data[hash] = data;
-    markDirty();
+    QHash<QString, QVariant> torrent = value(hash).toHash();
+    torrent["has_error"] = has_error;
+    setValue(hash, torrent);
 }
 
-bool TorrentPersistentData::hasError(const QString &hash)
+bool TorrentPersistentData::hasError(const QString &hash) const
 {
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("has_error", false).toBool();
+    const QHash<QString, QVariant> torrent = value(hash).toHash();
+    return torrent.value("has_error", false).toBool();
 }
 
-QDateTime TorrentPersistentData::getSeedDate(const QString &hash)
+QDateTime TorrentPersistentData::getSeedDate(const QString &hash) const
 {
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("seed_date").toDateTime();
+    const QHash<QString, QVariant> torrent = value(hash).toHash();
+    return torrent.value("seed_date").toDateTime();
 }
 
 void TorrentPersistentData::deletePersistentData(const QString &hash)
 {
-    if (all_data.contains(hash)) {
-        all_data.remove(hash);
-        markDirty();
+    QWriteLocker locker(&lock);
+    if (m_data.contains(hash)) {
+        m_data.remove(hash);
+        dirty = true;
+        timer.start();
     }
 }
 
 void TorrentPersistentData::saveTorrentPersistentData(const QTorrentHandle &h, const QString &save_path, const bool is_magnet)
 {
     Q_ASSERT(h.is_valid());
-    qDebug("Saving persistent data for %s", qPrintable(h.hash()));
+    QString hash = h.hash();
+    qDebug("Saving persistent data for %s", qPrintable(hash));
     // Save persistent data
-    QHash<QString, QVariant> data = all_data.value(h.hash()).toHash();
-    data["is_magnet"] = is_magnet;
+    QHash<QString, QVariant> torrent = value(hash).toHash();
+    torrent["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();
+        torrent["magnet_uri"] = misc::toQString(make_magnet_uri(h));
+    torrent["seed"] = h.is_seed();
+    torrent["priority"] = h.queue_position();
     if (save_path.isEmpty()) {
         qDebug("TorrentPersistantData: save path is %s", qPrintable(h.save_path()));
-        data["save_path"] = h.save_path();
+        torrent["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)
+        torrent["save_path"] = save_path; // Override torrent save path (e.g. because it is a temp dir)
     }
     // Label
-    data["label"] = TorrentTempData::getLabel(h.hash());
+    torrent["label"] = TorrentTempData::getLabel(hash);
     // Save data
-    all_data[h.hash()] = data;
-    markDirty();
-    qDebug("TorrentPersistentData: Saving save_path %s, hash: %s", qPrintable(h.save_path()), qPrintable(h.hash()));
+    setValue(hash, torrent);
+    qDebug("TorrentPersistentData: Saving save_path %s, hash: %s", qPrintable(h.save_path()), qPrintable(hash));
     // Set Added date
-    setAddedDate(h.hash(), QDateTime::currentDateTime());
+    setAddedDate(hash, QDateTime::currentDateTime());
     // Finally, remove temp data
-    TorrentTempData::deleteTempData(h.hash());
+    TorrentTempData::deleteTempData(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();
+    QHash<QString, QVariant> torrent = value(hash).toHash();
+    torrent["save_path"] = save_path;
+    setValue(hash, torrent);
     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();
+    QHash<QString, QVariant> torrent = value(hash).toHash();
+    torrent["label"] = label;
+    setValue(hash, torrent);
 }
 
 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();
+    QHash<QString, QVariant> torrent = value(hash).toHash();
+    torrent["name"] = name;
+    setValue(hash, torrent);
 }
 
 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();
+    QString hash = h.hash();
+    QHash<QString, QVariant> torrent = value(hash).toHash();
+    torrent["priority"] = h.queue_position();
+    setValue(hash, torrent);
 }
 
 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();
+    QHash<QString, QVariant> torrent = value(hash).toHash();
+    torrent["priority"] = queue_pos;
+    setValue(hash, torrent);
 }
 
 void TorrentPersistentData::saveSeedStatus(const QTorrentHandle &h)
 {
-    QHash<QString, QVariant> data = all_data[h.hash()].toHash();
-    bool was_seed = data.value("seed", false).toBool();
+    QString hash = h.hash();
+    QHash<QString, QVariant> torrent = value(hash).toHash();
+    bool was_seed = torrent.value("seed", false).toBool();
     if (was_seed != h.is_seed()) {
-        data["seed"] = !was_seed;
-        all_data[h.hash()] = data;
-        markDirty();
+        torrent["seed"] = !was_seed;
+        setValue(hash, torrent);
     }
 }
 
 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();
+    QHash<QString, QVariant> torrent = value(hash).toHash();
+    torrent["seed"] = seedStatus;
+    setValue(hash, torrent);
 }
 
-QString TorrentPersistentData::getSavePath(const QString &hash)
+QString TorrentPersistentData::getSavePath(const QString &hash) const
 {
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
+    const QHash<QString, QVariant> torrent = value(hash).toHash();
     //qDebug("TorrentPersistentData: getSavePath %s", data["save_path"].toString().toLocal8Bit().data());
-    return data.value("save_path").toString();
+    return torrent.value("save_path").toString();
 }
 
-QString TorrentPersistentData::getLabel(const QString &hash)
+QString TorrentPersistentData::getLabel(const QString &hash) const
 {
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("label", "").toString();
+    const QHash<QString, QVariant> torrent = value(hash).toHash();
+    return torrent.value("label", "").toString();
 }
 
-QString TorrentPersistentData::getName(const QString &hash)
+QString TorrentPersistentData::getName(const QString &hash) const
 {
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("name", "").toString();
+    const QHash<QString, QVariant> torrent = value(hash).toHash();
+    return torrent.value("name", "").toString();
 }
 
-int TorrentPersistentData::getPriority(const QString &hash)
+int TorrentPersistentData::getPriority(const QString &hash) const
 {
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("priority", -1).toInt();
+    const QHash<QString, QVariant> torrent = value(hash).toHash();
+    return torrent.value("priority", -1).toInt();
 }
 
-bool TorrentPersistentData::isSeed(const QString &hash)
+bool TorrentPersistentData::isSeed(const QString &hash) const
 {
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("seed", false).toBool();
+    const QHash<QString, QVariant> torrent = value(hash).toHash();
+    return torrent.value("seed", false).toBool();
 }
 
-bool TorrentPersistentData::isMagnet(const QString &hash)
+bool TorrentPersistentData::isMagnet(const QString &hash) const
 {
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    return data.value("is_magnet", false).toBool();
+    const QHash<QString, QVariant> torrent = value(hash).toHash();
+    return torrent.value("is_magnet", false).toBool();
 }
 
-QString TorrentPersistentData::getMagnetUri(const QString &hash)
+QString TorrentPersistentData::getMagnetUri(const QString &hash) const
 {
-    const QHash<QString, QVariant> data = all_data.value(hash).toHash();
-    Q_ASSERT(data.value("is_magnet", false).toBool());
-    return data.value("magnet_uri").toString();
-}
-
-void TorrentPersistentData::markDirty()
-{
-    if (!dirty) {
-        dirty = true;
-        timer.start(1000);
-    }
-}
-
-void TorrentPersistentData::saveImpl()
-{
-    Q_ASSERT(dirty);
-
-    QIniSettings settings(QString::fromUtf8("qBittorrent"), QString::fromUtf8("qBittorrent-resume"));
-    settings.setValue("torrents", all_data);
-    dirty = false;
-    timer.stop();
+    const QHash<QString, QVariant> torrent = value(hash).toHash();
+    Q_ASSERT(torrent.value("is_magnet", false).toBool());
+    return torrent.value("magnet_uri").toString();
 }

src/torrentpersistentdata.h

@@ -35,6 +35,7 @@
 #include <QObject>
 #include <QStringList>
 #include <QTimer>
+#include <QReadWriteLock>
 #include <vector>
 #include "preferences.h"
 
@@ -118,7 +119,7 @@ class TorrentPersistentData: QObject
 {
     Q_OBJECT
     Q_DISABLE_COPY(TorrentPersistentData)
-    // This class stores strings w/o modifying separators
+
 public:
     enum RatioLimit
     {
@@ -126,24 +127,20 @@ public:
         NO_RATIO_LIMIT = -1
     };
 
-public:
-    TorrentPersistentData();
+    static TorrentPersistentData* instance();
+    static void drop();
     ~TorrentPersistentData();
-    void save();
-
-public:
-    static TorrentPersistentData& instance();
 
-    bool isKnownTorrent(QString hash);
-    QStringList knownTorrents();
+    bool isKnownTorrent(QString hash) const;
+    QStringList knownTorrents() const;
     void setRatioLimit(const QString &hash, const qreal &ratio);
-    qreal getRatioLimit(const QString &hash);
-    bool hasPerTorrentRatioLimit();
+    qreal getRatioLimit(const QString &hash) const;
+    bool hasPerTorrentRatioLimit() const;
     void setAddedDate(const QString &hash, const QDateTime &time);
-    QDateTime getAddedDate(const QString &hash);
+    QDateTime getAddedDate(const QString &hash) const;
     void setErrorState(const QString &hash, const bool has_error);
-    bool hasError(const QString &hash);
-    QDateTime getSeedDate(const QString &hash);
+    bool hasError(const QString &hash) const;
+    QDateTime getSeedDate(const QString &hash) const;
     void deletePersistentData(const QString &hash);
     void saveTorrentPersistentData(const QTorrentHandle &h, const QString &save_path = QString::null, const bool is_magnet = false);
 
@@ -157,25 +154,27 @@ public:
     void saveSeedStatus(const QString &hash, const bool seedStatus);
 
     // Getters
-    QString getSavePath(const QString &hash);
-    QString getLabel(const QString &hash);
-    QString getName(const QString &hash);
-    int getPriority(const QString &hash);
-    bool isSeed(const QString &hash);
-    bool isMagnet(const QString &hash);
-    QString getMagnetUri(const QString &hash);
-
-private:
-    void markDirty();
-
-private slots:
-    void saveImpl();
+    QString getSavePath(const QString &hash) const;
+    QString getLabel(const QString &hash) const;
+    QString getName(const QString &hash) const;
+    int getPriority(const QString &hash) const;
+    bool isSeed(const QString &hash) const;
+    bool isMagnet(const QString &hash) const;
+    QString getMagnetUri(const QString &hash) const;
+
+public slots:
+    void save();
 
 private:
-    QHash<QString, QVariant> all_data;
+    TorrentPersistentData();
+    static TorrentPersistentData* m_instance;
+    QHash<QString, QVariant> m_data;
     bool dirty;
     QTimer timer;
-    static TorrentPersistentData* m_instance;
+    mutable QReadWriteLock lock;
+    const QVariant value(const QString &key, const QVariant &defaultValue = QVariant()) const;
+    void setValue(const QString &key, const QVariant &value);
+
 };
 
 #endif // TORRENTPERSISTENTDATA_H

src/transferlistwidget.cpp

@@ -251,7 +251,7 @@ void TransferListWidget::setSelectedTorrentsLocation()
     const QStringList hashes = getSelectedTorrentsHashes();
     if (hashes.isEmpty()) return;
     QString dir;
-    const QDir saveDir(TorrentPersistentData::instance().getSavePath(hashes.first()));
+    const QDir saveDir(TorrentPersistentData::instance()->getSavePath(hashes.first()));
     qDebug("Old save path is %s", qPrintable(saveDir.absolutePath()));
     dir = QFileDialog::getExistingDirectory(this, tr("Choose save path"), saveDir.absolutePath(),
                                             QFileDialog::DontConfirmOverwrite | QFileDialog::ShowDirsOnly | QFileDialog::HideNameFilterDetails);
@@ -268,7 +268,7 @@ void TransferListWidget::setSelectedTorrentsLocation()
                 h.move_storage(savePath.absolutePath());
             }
             else {
-                TorrentPersistentData::instance().saveSavePath(h.hash(), savePath.absolutePath());
+                TorrentPersistentData::instance()->saveSavePath(h.hash(), savePath.absolutePath());
                 main_window->getProperties()->updateSavePath(h);
             }
         }

src/webui/btjson.cpp

@@ -415,7 +415,7 @@ QByteArray btjson::getPropertiesForTorrent(const QString& hash)
             return QByteArray();
 
         // Save path
-        QString save_path = fsutils::toNativePath(TorrentPersistentData::instance().getSavePath(hash));
+        QString save_path = fsutils::toNativePath(TorrentPersistentData::instance()->getSavePath(hash));
         if (save_path.isEmpty())
             save_path = fsutils::toNativePath(h.save_path());
         data[KEY_PROP_SAVE_PATH] = save_path;
@@ -554,7 +554,7 @@ QVariantMap toMap(const QTorrentHandle& h)
     ret[KEY_TORRENT_SEQUENTIAL_DOWNLOAD] = status.sequential_download;
     if (h.has_metadata())
         ret[KEY_TORRENT_FIRST_LAST_PIECE_PRIO] = h.first_last_piece_first();
-    ret[KEY_TORRENT_LABEL] = TorrentPersistentData::instance().getLabel(h.hash());
+    ret[KEY_TORRENT_LABEL] = TorrentPersistentData::instance()->getLabel(h.hash());
 
     return ret;
 }

src/webui/qtorrentfilter.cpp

@@ -116,5 +116,5 @@ bool QTorrentFilter::torrentHasLabel(const QTorrentHandle &h) const
     if (label_.isNull())
         return true;
     else
-        return TorrentPersistentData::instance().getLabel(h.hash()) == label_;
+        return TorrentPersistentData::instance()->getLabel(h.hash()) == label_;
 }