Make the archive cache useful

Read the cache if there is one, if not, read it in another thread and
update the view when it's done.

1 files changed, 40 insertions, 40 deletions

diff --git a/archivemodel.cpp b/archivemodel.cpp
index a5d2298..67b875b 100644
--- a/archivemodel.cpp
+++ b/archivemodel.cpp
@@ -10,6 +10,7 @@
 #include <QFile>
 #include <QSettings>
 #include <QMutexLocker>
+#include <QSignalMapper>
 
 #include "smtreeitem.h"
 #include "archivemodel.h"
@@ -19,8 +20,19 @@ ArchiveModel::ArchiveModel(const QStringList &headers, QObject *parent) : SmTree
     mAvailableOrders.insert("Series Name", SeriesName);
     mAvailableOrders.insert("Actor", Actor);
     mAvailableOrders.insert("Genre", Genre);
-    mCollector = new ArchiveCollector(NumFields, this);
-    connect(mCollector, SIGNAL(finished()), this, SLOT(collectorFinished()));
+    QSignalMapper *collectorMapper = new QSignalMapper(this);
+    ArchiveCollector *c1 = new ArchiveCollector(NumFields, SeriesName, this);
+    connect(c1, SIGNAL(finished()), collectorMapper, SLOT(map()));
+    collectorMapper->setMapping(c1, c1);
+    ArchiveCollector *c2 = new ArchiveCollector(NumFields, Actor, this);
+    connect(c2, SIGNAL(finished()), collectorMapper, SLOT(map()));
+    collectorMapper->setMapping(c2, c2);
+    ArchiveCollector *c3 = new ArchiveCollector(NumFields, Genre, this);
+    connect(c3, SIGNAL(finished()), collectorMapper, SLOT(map()));
+    collectorMapper->setMapping(c3, c3);
+    connect(collectorMapper, SIGNAL(mapped(QObject*)), this, SLOT(collectorFinished(QObject*)));
+    mCollectors << c1 << c2 << c3;
+    refresh();
 }
 
 const QStringList ArchiveModel::availableOrders() const {
@@ -97,7 +109,7 @@ bool ArchiveModel::setData(const QModelIndex &idx, const QVariant &value, int ro
             emit needRefresh();
             return true;
         }
-        writeCache(mOrder);
+        writeCache(mOrder, root());
         return true;
     }else{
         emitDatabaseError(updateQuery.lastError());
@@ -202,12 +214,6 @@ void ArchiveModel::setOrder(int order) {
     SmTreeItem *rootItem = readCache(mOrder);
     if(rootItem){
         setRoot(rootItem);
-    }else{
-        rootItem = new SmTreeItem(NumFields);
-        mCollector->populate(mOrder, rootItem);
-        if(!mCollector->isRunning()){
-            mCollector->start();
-        }
     }
 }
 
@@ -217,13 +223,25 @@ void ArchiveModel::setOrder(const QString &order){
 }
 
 void ArchiveModel::refresh(){
-    setOrder(mOrder);
+    emit message(tr("Reading archive data..."));
+    foreach(ArchiveCollector *c, mCollectors){
+        c->start();
+    }
 }
 
-void ArchiveModel::collectorFinished(){
-    SmTreeItem *item = mCollector->rootItem();
-    setRoot(item);
-    writeCache(mOrder);
+void ArchiveModel::collectorFinished(QObject *thread){
+    QMutexLocker l(&mDoneMx);
+    ArchiveCollector *t = qobject_cast<ArchiveCollector*>(thread);
+    Q_ASSERT(t);
+    SmTreeItem *item = t->rootItem();
+    int sortOrder = t->sortOrder();
+    if(sortOrder == mOrder){
+        setRoot(item);
+    }
+    writeCache(sortOrder, item);
+    QString sortOrderName = mAvailableOrders.key(sortOrder);
+    QString msg = QString("Done reading %1").arg(sortOrderName);
+    emit message(msg);
 }
 
 bool ArchiveModel::checkParents(const SmTreeItem *item, const QRegExp &regex, int column) const {
@@ -244,15 +262,15 @@ void ArchiveModel::emitDatabaseError(const QSqlError &e){
     emit databaseError(errormsg);
 }
 
-void ArchiveModel::writeCache(int o){
+void ArchiveModel::writeCache(int o, SmTreeItem *rItem){
     QFile cache(cacheFile(o));
     cache.open(QIODevice::WriteOnly);
     QDataStream stream(&cache);
     // write root id, no need to write data
     // it's invalid anyway, we just need it as an anchor
-    stream << (qint64)root();
-    for(int i = 0; i < root()->childCount(); ++i){
-        writeRecursive(root()->child(i), stream);
+    stream << (qint64)rItem;
+    for(int i = 0; i < rItem->childCount(); ++i){
+        writeRecursive(rItem->child(i), stream);
     }
 }
 
@@ -332,25 +350,11 @@ const QString ArchiveModel::cacheFile(int o) const{
     return cacheFile;
 }
 
-ArchiveCollector::ArchiveCollector(int numFields, QObject *parent) : QThread(parent), mNumFields(numFields) {
-    mDb = QSqlDatabase::cloneDatabase(QSqlDatabase::database("treedb"), "archivedb");
+ArchiveCollector::ArchiveCollector(int numFields, int order, QObject *parent) : QThread(parent), mNumFields(numFields), mSortOrder(order) {
+    QString dbName = QString("%1").arg((qint64(this)));
+    mDb = QSqlDatabase::cloneDatabase(QSqlDatabase::database("treedb"), dbName);
     mDb.open();
-}
-
-SmTreeItem *ArchiveCollector::rootItem() {
-    QMutexLocker l(&mAccessMx);
-    return mRootItem;
-}
-
-int ArchiveCollector::sortOrder() {
-    QMutexLocker l(&mAccessMx);
-    return mSortOrder;
-}
-
-void ArchiveCollector::populate(int order, SmTreeItem *rootItem){
-    QMutexLocker l(&mAccessMx);
-    mRootItem = rootItem;
-    mSortOrder = order;
+    mRootItem = new SmTreeItem(numFields);
 }
 
 void ArchiveCollector::run(){
@@ -372,8 +376,6 @@ void ArchiveCollector::run(){
 void ArchiveCollector::populateBySeriesName() {
     fetchSeries(QVariant(), mRootItem);
     for(int i = 0; i < mRootItem->childCount(); ++i){
-        QString msg = QString("Processing %1").arg(mRootItem->child(i)->data(ArchiveModel::Name).toString());
-        emit message(msg);
         fetchParts(QVariant(), mRootItem->child(i));
     }
 }
@@ -402,8 +404,6 @@ void ArchiveCollector::populateByActor(){
 
 void ArchiveCollector::fetchChildren(SmTreeItem *parent){
     for(int i = 0; i < parent->childCount(); ++i){
-        QString msg = QString("Processing %1").arg(parent->child(i)->data(ArchiveModel::Name).toString());
-        emit message(msg);
         fetchSeries(parent->child(i)->data(ArchiveModel::GenericId), parent->child(i));
         for(int j = 0; j < parent->child(i)->childCount(); ++j){
             SmTreeItem *seriesItem = parent->child(i)->child(j);