Added explicit namespaces to usages of file and service options to fi…

…x compilation issues
PhilInTheGaps · Dec 17, 2023 · 4e9b2c6 · 4e9b2c6
1 parent 246f6aa
commit 4e9b2c6
Show file tree

Hide file tree

Showing 14 changed files with 62 additions and 43 deletions.
diff --git a/src/services/nextcloud/nextcloud.cpp b/src/services/nextcloud/nextcloud.cpp
@@ -94,7 +94,7 @@ auto NextCloud::sendDavRequest(const QByteArray &method, const QString &path, co
         }
     }
 
-    return m_connector.customRequest(request, method, data, Option::Authenticated | options);
+    return m_connector.customRequest(request, method, data, Services::Option::Authenticated | options);
 }
 
 auto NextCloud::getPathUrl(const QString &path) const -> QString

diff --git a/src/services/nextcloud/nextcloudconnector.cpp b/src/services/nextcloud/nextcloudconnector.cpp
@@ -129,7 +129,7 @@ void NextCloudConnector::sendRequest(RestRequest &&container, QPromise<RestReply
         request.setUrl(url);
     }
 
-    if (container.options().testFlag(Option::Authenticated))
+    if (container.options().testFlag(Services::Option::Authenticated))
     {
         request.setRawHeader("Authorization", NetworkUtils::basicAuthHeader(m_nc->loginName(), m_appPassword));
     }

diff --git a/src/services/rest/restserviceconnector.cpp b/src/services/rest/restserviceconnector.cpp
@@ -168,7 +168,7 @@ auto RESTServiceConnector::enqueueRequest(RestRequest &&request, QPromise<RestRe
     request.id(m_nextQueueId);
     m_nextQueueId++;
 
-    if (request.options().testFlag(Option::LowPriority))
+    if (request.options().testFlag(Services::Option::LowPriority))
     {
         m_requestQueueLowPriority.emplace(std::move(reply), std::move(request));
     }

diff --git a/src/services/rest/restserviceconnectorlocal.cpp b/src/services/rest/restserviceconnectorlocal.cpp
@@ -96,7 +96,7 @@ void RESTServiceConnectorLocal::sendRequest(RestRequest &&container, QPromise<Re
     auto *requestor = makeRequestor();
     auto request = container.request();
 
-    if (container.options().testFlag(Option::Authenticated))
+    if (container.options().testFlag(Services::Option::Authenticated))
     {
         // Workaround for google drive requests
         if (!m_config.authHeaderFormat.isEmpty())

diff --git a/src/services/spotify/api/albumapi.cpp b/src/services/spotify/api/albumapi.cpp
@@ -47,7 +47,9 @@ auto AlbumAPI::getAlbum(const QString &id, Options options) -> QFuture<SpotifyAl
         return QtFuture::makeReadyFuture(album);
     };
 
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated | options).then(callback).unwrap();
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Services::Option::Authenticated | options)
+        .then(callback)
+        .unwrap();
 }
 
 auto AlbumAPI::getAlbumTracks(const QString &id, Options options) -> QFuture<SpotifyTrackList>
@@ -80,7 +82,9 @@ auto AlbumAPI::getAlbumTracks(const QString &id, Options options) -> QFuture<Spo
         return QtFuture::makeReadyFuture(tracklist);
     };
 
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated | options).then(callback).unwrap();
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Services::Option::Authenticated | options)
+        .then(callback)
+        .unwrap();
 }
 
 auto AlbumAPI::getAlbumTracks(SpotifyAlbum &&album, Options options) -> QFuture<SpotifyAlbum>
@@ -104,7 +108,9 @@ auto AlbumAPI::getAlbumTracks(SpotifyAlbum &&album, Options options) -> QFuture<
         return QtFuture::makeReadyFuture(album);
     };
 
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated | options).then(callback).unwrap();
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Services::Option::Authenticated | options)
+        .then(callback)
+        .unwrap();
 }
 
 auto AlbumAPI::getAlbumTracks(SpotifyTrackList &&tracklist, Options options) -> QFuture<SpotifyTrackList>
@@ -126,5 +132,7 @@ auto AlbumAPI::getAlbumTracks(SpotifyTrackList &&tracklist, Options options) ->
         return QtFuture::makeReadyFuture(tracklist);
     };
 
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated | options).then(callback).unwrap();
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Services::Option::Authenticated | options)
+        .then(callback)
+        .unwrap();
 }
diff --git a/src/services/spotify/api/playerapi.cpp b/src/services/spotify/api/playerapi.cpp
@@ -21,7 +21,7 @@ PlayerAPI::PlayerAPI(Spotify *parent) : m_spotify(parent)
 
 auto PlayerAPI::play() const -> QFuture<RestReply>
 {
-    return m_spotify->put(QUrl(u"https://api.spotify.com/v1/me/player/play"_s), {}, Option::Authenticated);
+    return m_spotify->put(QUrl(u"https://api.spotify.com/v1/me/player/play"_s), {}, Services::Option::Authenticated);
 }
 
 auto PlayerAPI::play(const QString &deviceId, const QJsonObject &body) const -> QFuture<RestReply>
@@ -36,7 +36,7 @@ auto PlayerAPI::play(const QString &deviceId, const QJsonObject &body) const ->
 
     const QJsonDocument content(body);
     return m_spotify->put(NetworkUtils::makeJsonRequest(url), content.toJson(QJsonDocument::JsonFormat::Compact),
-                          Option::Authenticated);
+                          Services::Option::Authenticated);
 }
 
 auto PlayerAPI::play(const QString &uri) const -> QFuture<RestReply>
@@ -99,7 +99,7 @@ auto PlayerAPI::pause(const QString &deviceId) const -> QFuture<RestReply>
         url.setQuery(query);
     }
 
-    return m_spotify->put(NetworkUtils::makeJsonRequest(url), {}, Option::Authenticated);
+    return m_spotify->put(NetworkUtils::makeJsonRequest(url), {}, Services::Option::Authenticated);
 }
 
 auto PlayerAPI::next() const -> QFuture<RestReply>
@@ -117,7 +117,7 @@ auto PlayerAPI::next(const QString &deviceId) const -> QFuture<RestReply>
         url.setQuery(query);
     }
 
-    return m_spotify->post(NetworkUtils::makeJsonRequest(url), {}, Option::Authenticated);
+    return m_spotify->post(NetworkUtils::makeJsonRequest(url), {}, Services::Option::Authenticated);
 }
 
 auto PlayerAPI::previous() const -> QFuture<RestReply>
@@ -135,7 +135,7 @@ auto PlayerAPI::previous(const QString &deviceId) const -> QFuture<RestReply>
         url.setQuery(query);
     }
 
-    return m_spotify->post(NetworkUtils::makeJsonRequest(url), {}, Option::Authenticated);
+    return m_spotify->post(NetworkUtils::makeJsonRequest(url), {}, Services::Option::Authenticated);
 }
 
 auto PlayerAPI::seek(int positionMs) const -> QFuture<RestReply>
@@ -155,7 +155,7 @@ auto PlayerAPI::seek(int positionMs, const QString &deviceId) const -> QFuture<R
 
     url.setQuery(query);
 
-    return m_spotify->put(NetworkUtils::makeJsonRequest(url), {}, Option::Authenticated);
+    return m_spotify->put(NetworkUtils::makeJsonRequest(url), {}, Services::Option::Authenticated);
 }
 
 auto PlayerAPI::getState() -> QFuture<SpotifyPlaybackState>
@@ -190,7 +190,7 @@ auto PlayerAPI::getState(const QStringList &additionalTypes, const QString &mark
         return QtFuture::makeReadyFuture(SpotifyPlaybackState::fromJson(QJsonDocument::fromJson(reply.data())));
     };
 
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated).then(callback).unwrap();
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Services::Option::Authenticated).then(callback).unwrap();
 }
 
 auto PlayerAPI::getCurrentlyPlaying() -> QFuture<SpotifyCurrentTrack>
@@ -227,7 +227,7 @@ auto PlayerAPI::getCurrentlyPlaying(const QStringList &additionalTypes, const QS
         return QtFuture::makeReadyFuture(SpotifyCurrentTrack::fromJson(reply.data()));
     };
 
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated).then(callback).unwrap();
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Services::Option::Authenticated).then(callback).unwrap();
 }
 
 auto PlayerAPI::transfer(const QStringList &deviceIds) const -> QFuture<RestReply>
@@ -243,7 +243,7 @@ auto PlayerAPI::transfer(const QStringList &deviceIds, bool play) const -> QFutu
 
     const auto doc = QJsonDocument(body);
     return m_spotify->put(NetworkUtils::makeJsonRequest(url), doc.toJson(QJsonDocument::Compact),
-                          Option::Authenticated);
+                          Services::Option::Authenticated);
 }
 
 auto PlayerAPI::devices() -> QFuture<SpotifyDeviceList>
@@ -256,7 +256,7 @@ auto PlayerAPI::devices() -> QFuture<SpotifyDeviceList>
         return SpotifyDevice::fromJson(devices);
     };
 
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated).then(callback);
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Services::Option::Authenticated).then(callback);
 }
 
 auto PlayerAPI::repeat(SpotifyRepeatMode mode) const -> QFuture<RestReply>
@@ -291,7 +291,7 @@ auto PlayerAPI::repeat(const QString &state, const QString &deviceId) const -> Q
     }
 
     url.setQuery(query);
-    return m_spotify->put(NetworkUtils::makeJsonRequest(url), {}, Option::Authenticated);
+    return m_spotify->put(NetworkUtils::makeJsonRequest(url), {}, Services::Option::Authenticated);
 }
 
 auto PlayerAPI::volume(int volumePercent) const -> QFuture<RestReply>
@@ -310,7 +310,7 @@ auto PlayerAPI::volume(int volumePercent, const QString &deviceId) const -> QFut
     }
 
     url.setQuery(query);
-    return m_spotify->put(NetworkUtils::makeJsonRequest(url), {}, Option::Authenticated);
+    return m_spotify->put(NetworkUtils::makeJsonRequest(url), {}, Services::Option::Authenticated);
 }
 
 auto PlayerAPI::shuffle(bool state) const -> QFuture<RestReply>
@@ -329,7 +329,7 @@ auto PlayerAPI::shuffle(bool state, const QString &deviceId) const -> QFuture<Re
     }
 
     url.setQuery(query);
-    return m_spotify->put(NetworkUtils::makeJsonRequest(url), {}, Option::Authenticated);
+    return m_spotify->put(NetworkUtils::makeJsonRequest(url), {}, Services::Option::Authenticated);
 }
 
 auto PlayerAPI::getRecentlyPlayed(int limit) const -> QFuture<RestReply>
@@ -364,7 +364,8 @@ auto PlayerAPI::getRecentlyPlayed(const QDateTime &after, const QDateTime &befor
     query.addQueryItem(u"limit"_s, QString::number(std::clamp(limit, 0, MAX_RECENTLY_PLAYED)));
 
     url.setQuery(query);
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated | Option::LowPriority);
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url),
+                          Services::Option::Authenticated | Services::Option::LowPriority);
 }
 
 auto PlayerAPI::addToQueue(const QString &uri) const -> QFuture<RestReply>
@@ -390,5 +391,5 @@ auto PlayerAPI::addToQueue(const QString &uri, const QString &deviceId) const ->
     }
 
     url.setQuery(query);
-    return m_spotify->post(NetworkUtils::makeJsonRequest(url), {}, Option::Authenticated);
+    return m_spotify->post(NetworkUtils::makeJsonRequest(url), {}, Services::Option::Authenticated);
 }
diff --git a/src/services/spotify/api/playlistsapi.cpp b/src/services/spotify/api/playlistsapi.cpp
@@ -40,7 +40,9 @@ auto PlaylistsAPI::getPlaylist(const QString &id, Options options) -> QFuture<Sp
         return QtFuture::makeReadyFuture(SpotifyPlaylist::fromJson(reply.data()));
     };
 
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated | options).then(callback).unwrap();
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Services::Option::Authenticated | options)
+        .then(callback)
+        .unwrap();
 }
 
 auto PlaylistsAPI::getPlaylistTracks(const QString &id, Options options) -> QFuture<SpotifyTrackList>
@@ -73,7 +75,9 @@ auto PlaylistsAPI::getPlaylistTracks(const QString &id, Options options) -> QFut
         return QtFuture::makeReadyFuture(tracklist);
     };
 
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated | options).then(callback).unwrap();
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Services::Option::Authenticated | options)
+        .then(callback)
+        .unwrap();
 }
 
 auto PlaylistsAPI::getPlaylistTracks(SpotifyTrackList &&tracklist, Options options) -> QFuture<SpotifyTrackList>
@@ -95,7 +99,9 @@ auto PlaylistsAPI::getPlaylistTracks(SpotifyTrackList &&tracklist, Options optio
         return QtFuture::makeReadyFuture(tracklist);
     };
 
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated | options).then(callback).unwrap();
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Services::Option::Authenticated | options)
+        .then(callback)
+        .unwrap();
 }
 
 auto PlaylistsAPI::updatePlaylist(const PlaylistConfig &config, Options options) const -> QFuture<RestReply>

diff --git a/src/services/spotify/api/tracksapi.cpp b/src/services/spotify/api/tracksapi.cpp
@@ -39,7 +39,9 @@ auto TracksAPI::getTrack(const QString &id, Options options) -> QFuture<SpotifyT
         return QtFuture::makeReadyFuture(SpotifyTrack::fromJson(reply.data()));
     };
 
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated | options).then(callback).unwrap();
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Services::Option::Authenticated | options)
+        .then(callback)
+        .unwrap();
 }
 
 auto TracksAPI::getTracks(const QStringList &ids, Options options) -> QFuture<std::vector<SpotifyTrack>>
@@ -88,7 +90,9 @@ auto TracksAPI::getTracks(const QStringList &ids, std::vector<SpotifyTrack> &&pr
         return QtFuture::makeReadyFuture(previous);
     };
 
-    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Option::Authenticated | options).then(callback).unwrap();
+    return m_spotify->get(NetworkUtils::makeJsonRequest(url), Services::Option::Authenticated | options)
+        .then(callback)
+        .unwrap();
 }
 
 auto TracksAPI::getNextBatch(const QStringList &ids, const std::vector<SpotifyTrack> &previous) -> QStringList

diff --git a/src/services/spotify/spotifyconnectorserver.cpp b/src/services/spotify/spotifyconnectorserver.cpp
@@ -53,8 +53,8 @@ void SpotifyConnectorServer::disconnectService()
 
 void SpotifyConnectorServer::sendRequest(RestRequest &&container, QPromise<RestReply> &&promise)
 {
-    auto request =
-        container.options().testFlag(Option::Authenticated) ? addAuthHeader(container.request()) : container.request();
+    auto request = container.options().testFlag(Services::Option::Authenticated) ? addAuthHeader(container.request())
+                                                                                 : container.request();
     QNetworkReply *reply = nullptr;
 
     switch (container.type())

diff --git a/src/tools/audio/audiosaveload.cpp b/src/tools/audio/audiosaveload.cpp
@@ -54,7 +54,7 @@ auto AudioSaveLoad::loadProjects(const QObject *context, FileListResult &&files)
         }
     }
 
-    auto futureContents = File::getDataAsync(fileNames, Option::AllowCache);
+    auto futureContents = File::getDataAsync(fileNames, Files::Option::AllowCache);
 
     return futureContents.then([context](const std::vector<FileDataResult> &contents) {
         qCDebug(gmAudioSaveLoad()) << "Found audio projects.";
@@ -79,7 +79,7 @@ auto AudioSaveLoad::findMissingFilesAsync(const QList<AudioFile *> &audioFiles,
 
     const auto filePaths = getFilePathsToCheck(audioFiles, basePath);
 
-    auto futureCheckResult = File::checkAsync(filePaths, Option::AllowCache);
+    auto futureCheckResult = File::checkAsync(filePaths, Files::Option::AllowCache);
     return futureCheckResult
         .then([audioFiles, basePath](const FileMultiCheckResult &multiResult) {
             const auto foundPaths = multiResult.existing();

diff --git a/src/tools/audio/playlist/resolvingaudioplaylist.cpp b/src/tools/audio/playlist/resolvingaudioplaylist.cpp
@@ -150,9 +150,9 @@ auto ResolvingAudioPlaylist::unwrapSpotify(qsizetype index, const AudioFile &fil
     switch (type)
     {
     case SpotifyUtils::SpotifyType::Playlist:
-        return Spotify::instance()->playlists.getPlaylistTracks(id, Option::None).then(callback);
+        return Spotify::instance()->playlists.getPlaylistTracks(id, Services::Option::None).then(callback);
     case SpotifyUtils::SpotifyType::Album:
-        return Spotify::instance()->albums.getAlbumTracks(id, Option::None).then(callback);
+        return Spotify::instance()->albums.getAlbumTracks(id, Services::Option::None).then(callback);
     default:
         qCCritical(gmAudioPlaylistResolving())
             << "loadPlaylistRecursiveSpotify(): not implemented for container type" << (int)type;
@@ -166,7 +166,7 @@ auto ResolvingAudioPlaylist::unwrapYouTube(qsizetype index, const AudioFile &fil
     if (!id.isValid()) return QtFuture::makeReadyFuture();
 
     return YouTube::instance()
-        ->getPlaylistInfoAsync(id, Option::None)
+        ->getPlaylistInfoAsync(id, Services::Option::None)
         .then([this, index](const YouTubePlaylist &playlist) {
             QList<AudioFile *> files;
             files.reserve(playlist.streams.size());
@@ -226,7 +226,7 @@ void ResolvingAudioPlaylist::loadSpotifyTitles(const QList<AudioFile *> &tracks)
         }
     };
 
-    Spotify::instance()->tracks.getTracks(trackIds, Option::LowPriority).then(callback);
+    Spotify::instance()->tracks.getTracks(trackIds, Services::Option::LowPriority).then(callback);
 }
 
 auto ResolvingAudioPlaylist::isPlaylist(const QString &file) -> bool

diff --git a/src/tools/audio/thumbnails/loaders/fileimageloader.cpp b/src/tools/audio/thumbnails/loaders/fileimageloader.cpp
@@ -15,7 +15,7 @@ auto FileImageLoader::loadImageAsync(const QString &path) -> QFuture<QPixmap>
         return QtFuture::makeReadyFuture(pixmap);
     }
 
-    auto future = File::getDataAsync(path, Option::AllowCache | Option::LowPriority);
+    auto future = File::getDataAsync(path, Files::Option::AllowCache | Files::Option::LowPriority);
 
     const auto callback = [path](const FileDataResult &result) {
         return QtConcurrent::run(loadFromFileResult, path, result);

diff --git a/src/tools/audio/thumbnails/loaders/spotifyimageloader.cpp b/src/tools/audio/thumbnails/loaders/spotifyimageloader.cpp
@@ -82,7 +82,7 @@ auto SpotifyImageLoader::loadPlaylistImageAsync(const QString &id) -> QFuture<QP
 {
     const auto playlistCallback = [id](const SpotifyPlaylist &playlist) {
         const auto url = playlist.images.front().url;
-        auto future = Services::Spotify::instance()->get(url, Option::LowPriority);
+        auto future = Services::Spotify::instance()->get(url, Services::Option::LowPriority);
 
         const auto imageCallback = [id, url](const RestReply &reply) {
             QPixmap image;
@@ -99,7 +99,7 @@ auto SpotifyImageLoader::loadPlaylistImageAsync(const QString &id) -> QFuture<QP
         return future.then(imageCallback);
     };
 
-    auto future = Spotify::instance()->playlists.getPlaylist(id, Option::LowPriority);
+    auto future = Spotify::instance()->playlists.getPlaylist(id, Services::Option::LowPriority);
     return future.then(playlistCallback).unwrap();
 }
 
@@ -114,7 +114,7 @@ void SpotifyImageLoader::startRequest(SpotifyUtils::SpotifyType type)
 
     qCDebug(gmAudioSpotifyImageLoader()) << "Sending batch request:" << url;
 
-    auto future = Spotify::instance()->get(url, Option::Authenticated | Option::LowPriority);
+    auto future = Spotify::instance()->get(url, Services::Option::Authenticated | Services::Option::LowPriority);
     future.then([type](RestReply &&reply) { receivedRequest(std::move(reply), type); });
 
     // Start timer again if there still are ids in the queue
@@ -158,7 +158,7 @@ void SpotifyImageLoader::receivedRequest(RestReply &&reply, SpotifyUtils::Spotif
         }
 
         const auto request = QNetworkRequest(url);
-        auto future = Spotify::instance()->get(request, Option::LowPriority);
+        auto future = Spotify::instance()->get(request, Services::Option::LowPriority);
 
         const auto callback = [id, url](const RestReply &imageReply) {
             QPixmap image;

diff --git a/src/tools/audio/thumbnails/loaders/youtubeimageloader.cpp b/src/tools/audio/thumbnails/loaders/youtubeimageloader.cpp
@@ -22,7 +22,7 @@ auto YouTubeImageLoader::loadImageAsync(const VideoId &id, QNetworkAccessManager
 
     // Get video info
     return YouTube::instance()
-        ->getStreamInfoAsync(id, Option::LowPriority)
+        ->getStreamInfoAsync(id, Services::Option::LowPriority)
         .then([networkManager](const YouTubeVideo &video) { return loadImageAsync(video, networkManager); })
         .unwrap();
 }
@@ -61,7 +61,7 @@ auto YouTubeImageLoader::loadImageAsync(const PlaylistId &id, QNetworkAccessMana
 
     // Get video info
     return YouTube::instance()
-        ->getPlaylistInfoAsync(id, Option::LowPriority)
+        ->getPlaylistInfoAsync(id, Services::Option::LowPriority)
         .then([networkManager](const YouTubePlaylist &playlist) { return loadImageAsync(playlist, networkManager); })
         .unwrap();