src/collection/BlockingQuery.cpp

   1 /*
   2  *  Copyright (c) 2007 Maximilian Kossick <maximilian.kossick@googlemail.com>
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  */
  18
  19 #include "BlockingQuery.h"
  20
  21 #include "debug.h"
  22
  23 #include <QCoreApplication>
  24 #include <QMutex>
  25 #include <QMutexLocker>
  26 #include <QStringList>
  27
  28 using namespace Meta;
  29
  30 struct BlockingQuery::Private
  31 {
  32     QueryMaker *qm;
  33     QMutex mutex;
  34 //    QWaitCondition wait;
  35     QStringList collectionIds;
  36     QMutex dataMutex;
  37     QHash<QString, DataList> data;
  38     QHash<QString, TrackList> track;
  39     QHash<QString, AlbumList> album;
  40     QHash<QString, ArtistList> artist;
  41     QHash<QString, GenreList> genre;
  42     QHash<QString, ComposerList> composer;
  43     QHash<QString, YearList> year;
  44     QHash<QString, QStringList> custom;
  45     bool done;
  46 };
  47
  48 BlockingQuery::BlockingQuery( QueryMaker *qm )
  49     : QObject()
  50     , d( new Private )
  51 {
  52     d->qm = qm;
  53     d->done = false;
  54 }
  55
  56 BlockingQuery::~BlockingQuery()
  57 {
  58     delete d->qm;
  59     delete d;
  60 }
  61
  62 void
  63 BlockingQuery::startQuery()
  64 {
  65     DEBUG_BLOCK
  66     connect( d->qm, SIGNAL( newResultReady( QString, Meta::DataList ) ), SLOT( result( QString, Meta::DataList ) ), Qt::DirectConnection );
  67     connect( d->qm, SIGNAL( newResultReady( QString, Meta::TrackList ) ), SLOT( result( QString, Meta::TrackList ) ), Qt::DirectConnection );
  68     connect( d->qm, SIGNAL( newResultReady( QString, Meta::AlbumList ) ), SLOT( result( QString, Meta::AlbumList ) ), Qt::DirectConnection );
  69     connect( d->qm, SIGNAL( newResultReady( QString, Meta::ArtistList ) ), SLOT( result( QString, Meta::ArtistList ) ), Qt::DirectConnection );
  70     connect( d->qm, SIGNAL( newResultReady( QString, Meta::ComposerList ) ), SLOT( result( QString, Meta::ComposerList ) ), Qt::DirectConnection );
  71     connect( d->qm, SIGNAL( newResultReady( QString, Meta::YearList ) ), SLOT( result( QString, Meta::YearList ) ), Qt::DirectConnection );
  72     connect( d->qm, SIGNAL( newResultReady( QString, QStringList ) ), SLOT( result( QString, QStringList ) ), Qt::DirectConnection );
  73     connect( d->qm, SIGNAL( queryDone() ), SLOT( queryDone() ), Qt::DirectConnection );
  74
  75     d->mutex.lock();
  76     d->qm->run();
  77     while( !d->done )
  78     {
  79         d->mutex.unlock();
  80         QCoreApplication::instance()->processEvents( QEventLoop::AllEvents );
  81         d->mutex.lock();
  82     }
  83     d->mutex.unlock();
  84 }
  85
  86 QStringList
  87 BlockingQuery::collectionIds()
  88 {
  89     QMutexLocker locker( &d->dataMutex );
  90     return d->collectionIds;
  91 }
  92
  93 DataList
  94 BlockingQuery::data( const QString &id )
  95 {
  96     QMutexLocker locker( &d->dataMutex );
  97     return d->data.value( id );
  98 }
  99
 100 TrackList
 101 BlockingQuery::tracks( const QString &id )
 102 {
 103     QMutexLocker locker( &d->dataMutex );
 104     return d->track.value( id );
 105 }
 106
 107 AlbumList
 108 BlockingQuery::albums( const QString &id )
 109 {
 110     QMutexLocker locker( &d->dataMutex );
 111     return d->album.value( id );
 112 }
 113
 114 ArtistList
 115 BlockingQuery::artists( const QString &id )
 116 {
 117     QMutexLocker locker( &d->dataMutex );
 118     return d->artist.value( id );
 119 }
 120
 121 GenreList
 122 BlockingQuery::genres( const QString &id )
 123 {
 124     QMutexLocker locker( &d->dataMutex );
 125     return d->genre.value( id );
 126 }
 127
 128 ComposerList
 129 BlockingQuery::composers( const QString &id )
 130 {
 131     QMutexLocker locker( &d->dataMutex );
 132     return d->composer.value( id );
 133 }
 134
 135 YearList
 136 BlockingQuery::years( const QString &id )
 137 {
 138     QMutexLocker locker( &d->dataMutex );
 139     return d->year.value( id );
 140 }
 141
 142 QStringList
 143 BlockingQuery::customData( const QString &id )
 144 {
 145     QMutexLocker locker( &d->dataMutex );
 146     return d->custom.value( id );
 147 }
 148
 149 QHash<QString, DataList>
 150 BlockingQuery::data()
 151 {
 152     QMutexLocker locker( &d->dataMutex );
 153     return d->data;
 154 }
 155
 156 QHash<QString, TrackList>
 157 BlockingQuery::tracks()
 158 {
 159     QMutexLocker locker( &d->dataMutex );
 160     return d->track;
 161 }
 162
 163 QHash<QString, AlbumList>
 164 BlockingQuery::albums()
 165 {
 166     QMutexLocker locker( &d->dataMutex );
 167     return d->album;
 168 }
 169
 170 QHash<QString, ArtistList>
 171 BlockingQuery::artists()
 172 {
 173     QMutexLocker locker( &d->dataMutex );
 174     return d->artist;
 175 }
 176
 177 QHash<QString, GenreList>
 178 BlockingQuery::genres()
 179 {
 180     QMutexLocker locker( &d->dataMutex );
 181     return d->genre;
 182 }
 183
 184 QHash<QString, ComposerList>
 185 BlockingQuery::composers()
 186 {
 187     QMutexLocker locker( &d->dataMutex );
 188     return d->composer;
 189 }
 190
 191 QHash<QString, YearList>
 192 BlockingQuery::years()
 193 {
 194     QMutexLocker locker( &d->dataMutex );
 195     return d->year;
 196 }
 197
 198 QHash<QString, QStringList>
 199 BlockingQuery::customData()
 200 {
 201     QMutexLocker locker( &d->dataMutex );
 202     return d->custom;
 203 }
 204
 205 void
 206 BlockingQuery::queryDone()
 207 {
 208     DEBUG_BLOCK
 209     //lock the mutex so we can be sure that we wait in run()
 210     d->mutex.lock();
 211     d->done = true;
 212     d->mutex.unlock();
 213     //d->wait.wakeAll();
 214 }
 215
 216 void
 217 BlockingQuery::result( const QString &collectionId, Meta::DataList data )
 218 {
 219     d->dataMutex.lock();
 220     d->collectionIds.append( collectionId );
 221     d->data.insert( collectionId, data );
 222     d->dataMutex.unlock();
 223 }
 224
 225 void
 226 BlockingQuery::result( const QString &collectionId, Meta::TrackList tracks )
 227 {
 228     d->dataMutex.lock();
 229     d->collectionIds.append( collectionId );
 230     d->track.insert( collectionId, tracks );
 231     d->dataMutex.unlock();
 232 }
 233
 234 void
 235 BlockingQuery::result( const QString &collectionId, Meta::ArtistList artists )
 236 {
 237     d->dataMutex.lock();
 238     d->collectionIds.append( collectionId );
 239     d->artist.insert( collectionId, artists );
 240     d->dataMutex.unlock();
 241 }
 242
 243 void
 244 BlockingQuery::result( const QString &collectionId, Meta::AlbumList albums )
 245 {
 246     d->dataMutex.lock();
 247     d->collectionIds.append( collectionId );
 248     d->album.insert( collectionId, albums );
 249     d->dataMutex.unlock();
 250 }
 251
 252 void
 253 BlockingQuery::result( const QString &collectionId, Meta::GenreList genres )
 254 {
 255     d->dataMutex.lock();
 256     d->collectionIds.append( collectionId );
 257     d->genre.insert( collectionId, genres );
 258     d->dataMutex.unlock();
 259 }
 260
 261 void
 262 BlockingQuery::result( const QString &collectionId, Meta::ComposerList composers )
 263 {
 264     d->dataMutex.lock();
 265     d->collectionIds.append( collectionId );
 266     d->composer.insert( collectionId, composers );
 267     d->dataMutex.unlock();
 268 }
 269
 270 void
 271 BlockingQuery::result( const QString &collectionId, Meta::YearList years )
 272 {
 273     d->dataMutex.lock();
 274     d->collectionIds.append( collectionId );
 275     d->year.insert( collectionId, years );
 276     d->dataMutex.unlock();
 277 }
 278
 279 void
 280 BlockingQuery::result( const QString &collectionId, const QStringList &list )
 281 {
 282     d->dataMutex.lock();
 283     d->collectionIds.append( collectionId );
 284     d->custom.insert( collectionId, list );
 285     d->dataMutex.unlock();
 286 }
 287
 288 #include "BlockingQuery.moc"