- Multithreaded deletionThread (harmonized with deleteThread)

src/deleteThread.h

@@ -23,31 +23,121 @@
 #define DELETETHREAD_H
 
 #include <QThread>
+#include <QMutex>
+#include <QWaitCondition>
+#include <QMutexLocker>
 
 #include "misc.h"
 
+class subDeleteThread : public QThread {
+  Q_OBJECT
+  private:
+    QString path;
+    bool abort;
+
+  public:
+    subDeleteThread(QObject *parent, QString path) : QThread(parent), path(path){
+      abort = false;
+    }
+
+    ~subDeleteThread(){
+      abort = true;
+      wait();
+    }
+
+  signals:
+    // For subthreads
+    void deletionSuccessST(subDeleteThread* st, QString path);
+    void deletionFailureST(subDeleteThread* st, QString path);
+
+  protected:
+    void run(){
+      if(misc::removePath(path))
+        emit deletionSuccessST(this, path);
+      else
+        emit deletionFailureST(this, path);
+      qDebug("deletion completed for %s", (const char*)path.toUtf8());
+    }
+};
+
 class deleteThread : public QThread {
   Q_OBJECT
 
   private:
-    QString path;
+    QStringList path_list;
+    QMutex mutex;
+    QWaitCondition condition;
+    bool abort;
+    QList<subDeleteThread*> subThreads;
 
-  public :
-    deleteThread(QString _path): path(_path){
-      start();
+  signals:
+    void deletionSuccess(QString path);
+    void deletionFailure(QString path);
+
+  public:
+    deleteThread(QObject* parent) : QThread(parent){
+      abort = false;
     }
 
     ~deleteThread(){
+      mutex.lock();
+      abort = true;
+      condition.wakeOne();
+      mutex.unlock();
+      subDeleteThread *st;
+      foreach(st, subThreads){
+        delete st;
+      }
       wait();
     }
 
-  signals:
-    void deletionFinished(deleteThread*) const;
+    void deletePath(QString path){
+      QMutexLocker locker(&mutex);
+      path_list << path;
+      if(!isRunning()){
+        start();
+      }else{
+        condition.wakeOne();
+      }
+    }
 
-  private:
+  protected:
     void run(){
-      misc::removePath(path);
-      emit deletionFinished(this);
+      forever{
+        if(abort)
+          return;
+        mutex.lock();
+        if(path_list.size() != 0){
+          QString path = path_list.takeFirst();
+          mutex.unlock();
+          subDeleteThread *st = new subDeleteThread(0, path);
+          subThreads << st;
+          connect(st, SIGNAL(deletionSuccessST(subDownloadThread*, QString, QString)), this, SLOT(propagateDeletionSuccess(subDeleteThread*, QString)));
+          connect(st, SIGNAL(deletionFailureST(subDownloadThread*, QString, QString)), this, SLOT(propagateDeletionFailure(subDeleteThread*, QString)));
+          st->start();
+        }else{
+          condition.wait(&mutex);
+          mutex.unlock();
+        }
+      }
+    }
+  protected slots:
+    void propagateDeletionSuccess(subDeleteThread* st, QString path){
+      int index = subThreads.indexOf(st);
+      Q_ASSERT(index != -1);
+      subThreads.removeAt(index);
+      delete st;
+      emit deletionSuccess(path);
+      qDebug("%s was successfully deleted", (const char*)path.toUtf8());
+    }
+
+    void propagateDeletionFailure(subDeleteThread* st, QString path){
+      int index = subThreads.indexOf(st);
+      Q_ASSERT(index != -1);
+      subThreads.removeAt(index);
+      delete st;
+      emit deletionFailure(path);
+      std::cerr << "Could not delete path: " << (const char*)path.toUtf8() << ". Check if qBittorrent has the required rights.\n";
     }
 };