2011-03-12 22:19:41 +01:00
|
|
|
/* This file is part of Clementine.
|
|
|
|
Copyright 2010, David Sansome <me@davidsansome.com>
|
|
|
|
|
|
|
|
Clementine is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
Clementine is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with Clementine. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "musicbrainzclient.h"
|
|
|
|
|
|
|
|
#include <QCoreApplication>
|
|
|
|
#include <QNetworkReply>
|
2012-01-07 22:51:02 +01:00
|
|
|
#include <QSet>
|
2015-04-11 22:52:31 +02:00
|
|
|
#include <QUrlQuery>
|
2020-09-18 16:15:19 +02:00
|
|
|
#include <QXmlStreamReader>
|
|
|
|
#include <algorithm>
|
2012-10-12 14:36:14 +02:00
|
|
|
|
|
|
|
#include "core/closure.h"
|
|
|
|
#include "core/logging.h"
|
|
|
|
#include "core/network.h"
|
|
|
|
#include "core/utilities.h"
|
2011-03-12 22:19:41 +01:00
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
const char* MusicBrainzClient::kTrackUrl =
|
|
|
|
"https://musicbrainz.org/ws/2/recording/";
|
|
|
|
const char* MusicBrainzClient::kDiscUrl =
|
|
|
|
"https://musicbrainz.org/ws/2/discid/";
|
2012-01-07 22:51:02 +01:00
|
|
|
const char* MusicBrainzClient::kDateRegex = "^[12]\\d{3}";
|
2014-02-07 16:34:20 +01:00
|
|
|
const int MusicBrainzClient::kDefaultTimeout = 5000; // msec
|
2014-08-11 00:37:02 +02:00
|
|
|
const int MusicBrainzClient::kMaxRequestPerTrack = 3;
|
2011-03-12 22:19:41 +01:00
|
|
|
|
2014-05-24 13:33:32 +02:00
|
|
|
MusicBrainzClient::MusicBrainzClient(QObject* parent,
|
|
|
|
QNetworkAccessManager* network)
|
2014-02-07 16:34:20 +01:00
|
|
|
: QObject(parent),
|
2014-05-24 13:33:32 +02:00
|
|
|
network_(network ? network : new NetworkAccessManager(this)),
|
2014-02-07 16:34:20 +01:00
|
|
|
timeouts_(new NetworkTimeouts(kDefaultTimeout, this)) {}
|
2011-03-12 22:19:41 +01:00
|
|
|
|
2014-08-09 01:48:35 +02:00
|
|
|
void MusicBrainzClient::Start(int id, const QStringList& mbid_list) {
|
2011-03-12 22:19:41 +01:00
|
|
|
typedef QPair<QString, QString> Param;
|
|
|
|
|
2014-08-09 01:48:35 +02:00
|
|
|
int request_number = 0;
|
|
|
|
for (const QString& mbid : mbid_list) {
|
|
|
|
QList<Param> parameters;
|
|
|
|
parameters << Param("inc", "artists+releases+media");
|
2011-03-12 22:19:41 +01:00
|
|
|
|
2014-08-09 01:48:35 +02:00
|
|
|
QUrl url(kTrackUrl + mbid);
|
2015-04-11 22:52:31 +02:00
|
|
|
QUrlQuery url_query;
|
|
|
|
url_query.setQueryItems(parameters);
|
|
|
|
url.setQuery(url_query);
|
2014-08-09 01:48:35 +02:00
|
|
|
QNetworkRequest req(url);
|
2011-03-12 22:19:41 +01:00
|
|
|
|
2014-08-09 01:48:35 +02:00
|
|
|
QNetworkReply* reply = network_->get(req);
|
|
|
|
NewClosure(reply, SIGNAL(finished()), this,
|
2015-06-14 08:45:39 +02:00
|
|
|
SLOT(RequestFinished(QNetworkReply*, int, int)), reply, id,
|
|
|
|
request_number++);
|
2014-08-09 01:48:35 +02:00
|
|
|
requests_.insert(id, reply);
|
2011-03-13 14:17:35 +01:00
|
|
|
|
2014-08-09 01:48:35 +02:00
|
|
|
timeouts_->AddReply(reply);
|
2014-08-11 00:37:02 +02:00
|
|
|
|
|
|
|
if (request_number >= kMaxRequestPerTrack) {
|
|
|
|
break;
|
|
|
|
}
|
2014-08-09 01:48:35 +02:00
|
|
|
}
|
2011-03-12 22:19:41 +01:00
|
|
|
}
|
|
|
|
|
2011-06-10 01:08:43 +02:00
|
|
|
void MusicBrainzClient::StartDiscIdRequest(const QString& discid) {
|
|
|
|
typedef QPair<QString, QString> Param;
|
|
|
|
|
|
|
|
QList<Param> parameters;
|
2012-11-18 22:11:47 +01:00
|
|
|
parameters << Param("inc", "artists+recordings");
|
2011-06-10 01:08:43 +02:00
|
|
|
|
2012-11-18 22:11:47 +01:00
|
|
|
QUrl url(kDiscUrl + discid);
|
2015-04-11 22:52:31 +02:00
|
|
|
QUrlQuery url_query;
|
|
|
|
url_query.setQueryItems(parameters);
|
|
|
|
url.setQuery(url_query);
|
2011-06-10 01:08:43 +02:00
|
|
|
QNetworkRequest req(url);
|
|
|
|
|
|
|
|
QNetworkReply* reply = network_->get(req);
|
2012-10-12 14:36:14 +02:00
|
|
|
NewClosure(reply, SIGNAL(finished()), this,
|
2014-05-24 13:33:32 +02:00
|
|
|
SLOT(DiscIdRequestFinished(const QString&, QNetworkReply*)),
|
|
|
|
discid, reply);
|
2011-06-10 01:08:43 +02:00
|
|
|
|
|
|
|
timeouts_->AddReply(reply);
|
|
|
|
}
|
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
void MusicBrainzClient::Cancel(int id) { delete requests_.take(id); }
|
2011-03-12 22:19:41 +01:00
|
|
|
|
|
|
|
void MusicBrainzClient::CancelAll() {
|
2012-10-12 14:36:14 +02:00
|
|
|
qDeleteAll(requests_.values());
|
2011-03-12 22:19:41 +01:00
|
|
|
requests_.clear();
|
|
|
|
}
|
|
|
|
|
2014-05-24 13:33:32 +02:00
|
|
|
void MusicBrainzClient::DiscIdRequestFinished(const QString& discid,
|
|
|
|
QNetworkReply* reply) {
|
2011-06-15 01:38:43 +02:00
|
|
|
reply->deleteLater();
|
2011-06-10 01:08:43 +02:00
|
|
|
|
|
|
|
ResultList ret;
|
|
|
|
QString artist;
|
|
|
|
QString album;
|
2015-06-14 08:45:39 +02:00
|
|
|
int year = 0;
|
2011-08-09 21:54:37 +02:00
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() !=
|
|
|
|
200) {
|
2020-09-18 16:15:19 +02:00
|
|
|
qLog(Error)
|
|
|
|
<< "Error:"
|
|
|
|
<< reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt()
|
|
|
|
<< "http status code received";
|
2021-09-01 21:21:43 +02:00
|
|
|
if (reply->isOpen()) qLog(Error) << reply->readAll();
|
2011-06-10 01:08:43 +02:00
|
|
|
emit Finished(artist, album, ret);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Parse xml result:
|
|
|
|
// -get title
|
|
|
|
// -get artist
|
2015-06-14 08:45:39 +02:00
|
|
|
// -get year
|
2011-06-10 01:08:43 +02:00
|
|
|
// -get all the tracks' tags
|
2014-05-24 13:33:32 +02:00
|
|
|
// Note: If there are multiple releases for the discid, the first
|
|
|
|
// release is chosen.
|
2011-06-10 01:08:43 +02:00
|
|
|
QXmlStreamReader reader(reply);
|
|
|
|
while (!reader.atEnd()) {
|
|
|
|
QXmlStreamReader::TokenType type = reader.readNext();
|
|
|
|
if (type == QXmlStreamReader::StartElement) {
|
|
|
|
QStringRef name = reader.name();
|
|
|
|
if (name == "title") {
|
|
|
|
album = reader.readElementText();
|
2015-06-14 08:45:39 +02:00
|
|
|
} else if (name == "date") {
|
|
|
|
QRegExp regex(kDateRegex);
|
|
|
|
if (regex.indexIn(reader.readElementText()) == 0) {
|
|
|
|
year = regex.cap(0).toInt();
|
|
|
|
}
|
2014-05-24 13:33:32 +02:00
|
|
|
} else if (name == "artist-credit") {
|
2011-06-10 01:08:43 +02:00
|
|
|
ParseArtist(&reader, &artist);
|
2014-05-24 13:33:32 +02:00
|
|
|
} else if (name == "medium-list") {
|
2011-06-10 01:08:43 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while (!reader.atEnd()) {
|
2011-08-09 21:54:37 +02:00
|
|
|
QXmlStreamReader::TokenType token = reader.readNext();
|
2014-05-24 13:33:32 +02:00
|
|
|
if (token == QXmlStreamReader::StartElement && reader.name() == "medium") {
|
|
|
|
// Get the medium with a matching discid.
|
|
|
|
if (MediumHasDiscid(discid, &reader)) {
|
|
|
|
ResultList tracks = ParseMedium(&reader);
|
|
|
|
for (const Result& track : tracks) {
|
|
|
|
if (!track.title_.isEmpty()) {
|
|
|
|
ret << track;
|
|
|
|
}
|
2012-01-07 22:51:02 +01:00
|
|
|
}
|
2021-05-15 15:43:14 +02:00
|
|
|
break; // stop after consuming one medium with correct discid!
|
2014-05-24 13:33:32 +02:00
|
|
|
} else {
|
|
|
|
Utilities::ConsumeCurrentElement(&reader);
|
2011-06-10 01:08:43 +02:00
|
|
|
}
|
2014-02-07 16:34:20 +01:00
|
|
|
} else if (token == QXmlStreamReader::EndElement &&
|
2014-05-24 13:33:32 +02:00
|
|
|
reader.name() == "medium-list") {
|
2011-08-09 21:54:37 +02:00
|
|
|
break;
|
2011-06-10 01:08:43 +02:00
|
|
|
}
|
|
|
|
}
|
2021-05-17 21:59:09 +02:00
|
|
|
if (reader.hasError()) {
|
|
|
|
qLog(Error) << "Received a reply from musicbrainz.org for" << discid
|
|
|
|
<< " but the XML was not well-formed.";
|
|
|
|
}
|
2011-06-10 01:08:43 +02:00
|
|
|
|
2015-06-14 08:45:39 +02:00
|
|
|
// If we parsed a year, copy it to the tracks.
|
|
|
|
if (year > 0) {
|
|
|
|
for (ResultList::iterator it = ret.begin(); it != ret.end(); ++it) {
|
|
|
|
it->year_ = year;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-10 14:22:42 +02:00
|
|
|
emit Finished(artist, album, UniqueResults(ret, SortResults));
|
2011-06-10 01:08:43 +02:00
|
|
|
}
|
|
|
|
|
2015-06-14 08:45:39 +02:00
|
|
|
void MusicBrainzClient::RequestFinished(QNetworkReply* reply, int id,
|
|
|
|
int request_number) {
|
2011-03-12 22:19:41 +01:00
|
|
|
reply->deleteLater();
|
|
|
|
|
2014-08-09 01:48:35 +02:00
|
|
|
const int nb_removed = requests_.remove(id, reply);
|
|
|
|
if (nb_removed != 1) {
|
2015-06-14 08:45:39 +02:00
|
|
|
qLog(Error)
|
|
|
|
<< "Error: unknown reply received:" << nb_removed
|
|
|
|
<< "requests removed, while only one was supposed to be removed";
|
2011-03-12 22:19:41 +01:00
|
|
|
}
|
|
|
|
|
2014-08-09 01:48:35 +02:00
|
|
|
if (reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() ==
|
|
|
|
200) {
|
|
|
|
QXmlStreamReader reader(reply);
|
|
|
|
ResultList res;
|
|
|
|
while (!reader.atEnd()) {
|
|
|
|
if (reader.readNext() == QXmlStreamReader::StartElement &&
|
|
|
|
reader.name() == "recording") {
|
|
|
|
ResultList tracks = ParseTrack(&reader);
|
|
|
|
for (const Result& track : tracks) {
|
|
|
|
if (!track.title_.isEmpty()) {
|
|
|
|
res << track;
|
|
|
|
}
|
2012-01-07 22:51:02 +01:00
|
|
|
}
|
2011-03-12 22:19:41 +01:00
|
|
|
}
|
|
|
|
}
|
2014-08-09 01:48:35 +02:00
|
|
|
pending_results_[id] << PendingResults(request_number, res);
|
2014-08-11 00:37:02 +02:00
|
|
|
} else {
|
2020-09-18 16:15:19 +02:00
|
|
|
qLog(Error)
|
|
|
|
<< "Error:"
|
|
|
|
<< reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt()
|
|
|
|
<< "http status code received";
|
2014-08-11 00:37:02 +02:00
|
|
|
qLog(Error) << reply->readAll();
|
2011-03-12 22:19:41 +01:00
|
|
|
}
|
|
|
|
|
2014-08-09 01:48:35 +02:00
|
|
|
// No more pending requests for this id: emit the results we have.
|
|
|
|
if (!requests_.contains(id)) {
|
|
|
|
// Merge the results we have
|
|
|
|
ResultList ret;
|
|
|
|
QList<PendingResults> result_list_list = pending_results_.take(id);
|
2018-10-05 17:19:05 +02:00
|
|
|
std::sort(result_list_list.begin(), result_list_list.end());
|
2014-08-09 01:48:35 +02:00
|
|
|
for (const PendingResults& result_list : result_list_list) {
|
|
|
|
ret << result_list.results_;
|
|
|
|
}
|
2014-08-10 14:22:42 +02:00
|
|
|
emit Finished(id, UniqueResults(ret, KeepOriginalOrder));
|
2014-08-09 01:48:35 +02:00
|
|
|
}
|
2011-03-12 22:19:41 +01:00
|
|
|
}
|
|
|
|
|
2014-05-24 13:33:32 +02:00
|
|
|
bool MusicBrainzClient::MediumHasDiscid(const QString& discid,
|
|
|
|
QXmlStreamReader* reader) {
|
|
|
|
while (!reader->atEnd()) {
|
|
|
|
QXmlStreamReader::TokenType type = reader->readNext();
|
|
|
|
|
|
|
|
if (type == QXmlStreamReader::StartElement && reader->name() == "disc" &&
|
|
|
|
reader->attributes().value("id").toString() == discid) {
|
|
|
|
return true;
|
|
|
|
} else if (type == QXmlStreamReader::EndElement &&
|
|
|
|
reader->name() == "disc-list") {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
qLog(Debug) << "Reached end of xml stream without encountering </disc-list>";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
MusicBrainzClient::ResultList MusicBrainzClient::ParseMedium(
|
|
|
|
QXmlStreamReader* reader) {
|
|
|
|
ResultList ret;
|
|
|
|
while (!reader->atEnd()) {
|
|
|
|
QXmlStreamReader::TokenType type = reader->readNext();
|
|
|
|
|
|
|
|
if (type == QXmlStreamReader::StartElement) {
|
|
|
|
if (reader->name() == "track") {
|
|
|
|
Result result;
|
|
|
|
result = ParseTrackFromDisc(reader);
|
|
|
|
ret << result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type == QXmlStreamReader::EndElement &&
|
|
|
|
reader->name() == "track-list") {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
MusicBrainzClient::Result MusicBrainzClient::ParseTrackFromDisc(
|
|
|
|
QXmlStreamReader* reader) {
|
|
|
|
Result result;
|
|
|
|
|
|
|
|
while (!reader->atEnd()) {
|
|
|
|
QXmlStreamReader::TokenType type = reader->readNext();
|
|
|
|
|
|
|
|
if (type == QXmlStreamReader::StartElement) {
|
|
|
|
QStringRef name = reader->name();
|
|
|
|
if (name == "position") {
|
|
|
|
result.track_ = reader->readElementText().toInt();
|
|
|
|
} else if (name == "length") {
|
|
|
|
result.duration_msec_ = reader->readElementText().toInt();
|
|
|
|
} else if (name == "title") {
|
|
|
|
result.title_ = reader->readElementText();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type == QXmlStreamReader::EndElement && reader->name() == "track") {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
MusicBrainzClient::ResultList MusicBrainzClient::ParseTrack(
|
|
|
|
QXmlStreamReader* reader) {
|
2012-01-07 22:51:02 +01:00
|
|
|
Result result;
|
|
|
|
QList<Release> releases;
|
2011-03-12 22:19:41 +01:00
|
|
|
|
|
|
|
while (!reader->atEnd()) {
|
|
|
|
QXmlStreamReader::TokenType type = reader->readNext();
|
|
|
|
|
|
|
|
if (type == QXmlStreamReader::StartElement) {
|
|
|
|
QStringRef name = reader->name();
|
|
|
|
|
|
|
|
if (name == "title") {
|
2012-01-07 22:51:02 +01:00
|
|
|
result.title_ = reader->readElementText();
|
2012-01-06 18:01:46 +01:00
|
|
|
} else if (name == "length") {
|
2012-01-07 22:51:02 +01:00
|
|
|
result.duration_msec_ = reader->readElementText().toInt();
|
2014-05-24 13:33:32 +02:00
|
|
|
} else if (name == "artist-credit") {
|
2012-01-07 22:51:02 +01:00
|
|
|
ParseArtist(reader, &result.artist_);
|
2011-03-12 22:19:41 +01:00
|
|
|
} else if (name == "release") {
|
2012-01-07 22:51:02 +01:00
|
|
|
releases << ParseRelease(reader);
|
2011-03-12 22:19:41 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-06 18:01:46 +01:00
|
|
|
if (type == QXmlStreamReader::EndElement && reader->name() == "recording") {
|
2011-03-12 22:19:41 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-07 22:51:02 +01:00
|
|
|
ResultList ret;
|
2012-11-18 22:11:47 +01:00
|
|
|
if (releases.isEmpty()) {
|
|
|
|
ret << result;
|
|
|
|
} else {
|
2018-10-05 17:19:05 +02:00
|
|
|
std::stable_sort(releases.begin(), releases.end());
|
2014-02-10 14:29:07 +01:00
|
|
|
for (const Release& release : releases) {
|
2012-11-18 22:11:47 +01:00
|
|
|
ret << release.CopyAndMergeInto(result);
|
|
|
|
}
|
2012-01-07 22:51:02 +01:00
|
|
|
}
|
2011-03-12 22:19:41 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-05-24 13:33:32 +02:00
|
|
|
// Parse the artist. Multiple artists are joined together with the
|
|
|
|
// joinphrase from musicbrainz.
|
2011-03-12 22:19:41 +01:00
|
|
|
void MusicBrainzClient::ParseArtist(QXmlStreamReader* reader, QString* artist) {
|
2014-05-24 13:33:32 +02:00
|
|
|
QString join_phrase;
|
2011-03-12 22:19:41 +01:00
|
|
|
while (!reader->atEnd()) {
|
|
|
|
QXmlStreamReader::TokenType type = reader->readNext();
|
|
|
|
|
2014-05-24 13:33:32 +02:00
|
|
|
if (type == QXmlStreamReader::StartElement &&
|
|
|
|
reader->name() == "name-credit") {
|
|
|
|
join_phrase = reader->attributes().value("joinphrase").toString();
|
|
|
|
}
|
|
|
|
|
2011-03-12 22:19:41 +01:00
|
|
|
if (type == QXmlStreamReader::StartElement && reader->name() == "name") {
|
2014-05-24 13:33:32 +02:00
|
|
|
*artist += reader->readElementText() + join_phrase;
|
2011-03-12 22:19:41 +01:00
|
|
|
}
|
|
|
|
|
2014-05-24 13:33:32 +02:00
|
|
|
if (type == QXmlStreamReader::EndElement &&
|
|
|
|
reader->name() == "artist-credit") {
|
2011-03-12 22:19:41 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-07 16:34:20 +01:00
|
|
|
MusicBrainzClient::Release MusicBrainzClient::ParseRelease(
|
|
|
|
QXmlStreamReader* reader) {
|
2012-01-07 22:51:02 +01:00
|
|
|
Release ret;
|
|
|
|
|
2011-03-12 22:19:41 +01:00
|
|
|
while (!reader->atEnd()) {
|
|
|
|
QXmlStreamReader::TokenType type = reader->readNext();
|
|
|
|
|
|
|
|
if (type == QXmlStreamReader::StartElement) {
|
|
|
|
QStringRef name = reader->name();
|
|
|
|
if (name == "title") {
|
2012-01-07 22:51:02 +01:00
|
|
|
ret.album_ = reader->readElementText();
|
2014-12-06 17:54:13 +01:00
|
|
|
} else if (name == "status") {
|
|
|
|
ret.SetStatusFromString(reader->readElementText());
|
2012-01-07 22:51:02 +01:00
|
|
|
} else if (name == "date") {
|
|
|
|
QRegExp regex(kDateRegex);
|
|
|
|
if (regex.indexIn(reader->readElementText()) == 0) {
|
|
|
|
ret.year_ = regex.cap(0).toInt();
|
|
|
|
}
|
2011-03-12 22:19:41 +01:00
|
|
|
} else if (name == "track-list") {
|
2014-02-07 16:34:20 +01:00
|
|
|
ret.track_ =
|
|
|
|
reader->attributes().value("offset").toString().toInt() + 1;
|
2012-01-07 22:51:02 +01:00
|
|
|
Utilities::ConsumeCurrentElement(reader);
|
2011-03-12 22:19:41 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type == QXmlStreamReader::EndElement && reader->name() == "release") {
|
2012-01-07 22:51:02 +01:00
|
|
|
break;
|
2011-03-12 22:19:41 +01:00
|
|
|
}
|
|
|
|
}
|
2012-01-07 22:51:02 +01:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-08-10 14:22:42 +02:00
|
|
|
MusicBrainzClient::ResultList MusicBrainzClient::UniqueResults(
|
|
|
|
const ResultList& results, UniqueResultsSortOption opt) {
|
|
|
|
ResultList ret;
|
|
|
|
if (opt == SortResults) {
|
2020-01-05 00:58:33 +01:00
|
|
|
ret = QSet<Result>::fromList(results).values();
|
2018-10-05 17:19:05 +02:00
|
|
|
std::sort(ret.begin(), ret.end());
|
2014-08-10 14:22:42 +02:00
|
|
|
} else { // KeepOriginalOrder
|
|
|
|
// Qt doesn't provide a ordered set (QSet "stores values in an unspecified
|
|
|
|
// order" according to Qt documentation).
|
|
|
|
// We might use std::set instead, but it's probably faster to use ResultList
|
|
|
|
// directly to avoid converting from one structure to another.
|
|
|
|
for (const Result& res : results) {
|
|
|
|
if (!ret.contains(res)) {
|
|
|
|
ret << res;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-08-10 13:20:11 +02:00
|
|
|
return ret;
|
2011-03-12 22:19:41 +01:00
|
|
|
}
|