From 255623bbfdbb35d4890183539da58459677b933f Mon Sep 17 00:00:00 2001 From: Jonas Kvinge Date: Sat, 7 Sep 2024 05:09:12 +0200 Subject: [PATCH] Replace QStringLiteral with `u""_s` operator --- src/core/iconmapper.h | 189 ++++--- src/core/song.cpp | 802 +++++++++++++++--------------- src/organize/organizeformat.cpp | 54 +- src/scrobbler/scrobblingapi20.cpp | 212 ++++---- src/utilities/timeutils.cpp | 56 ++- 5 files changed, 657 insertions(+), 656 deletions(-) diff --git a/src/core/iconmapper.h b/src/core/iconmapper.h index e37305e36..18949b7f1 100644 --- a/src/core/iconmapper.h +++ b/src/core/iconmapper.h @@ -40,104 +40,103 @@ struct IconProperties { static const QMap iconmapper_ = { // clazy:exclude=non-pod-global-static - { QStringLiteral("albums"), { {QStringLiteral("media-optical")}} }, - { QStringLiteral("alsa"), { {}} }, - { QStringLiteral("application-exit"), { {}} }, - { QStringLiteral("applications-internet"), { {}} }, - { QStringLiteral("bluetooth"), { {QStringLiteral("preferences-system-bluetooth"), QStringLiteral("bluetooth-active")}} }, - { QStringLiteral("cdcase"), { {QStringLiteral("cdcover"), QStringLiteral("media-optical")}} }, - { QStringLiteral("media-optical"), { {QStringLiteral("cd")}} }, - { QStringLiteral("configure"), { {}} }, - { QStringLiteral("device-ipod-nano"), { {}} }, - { QStringLiteral("device-ipod"), { {}} }, - { QStringLiteral("device-phone"), { {}} }, - { QStringLiteral("device"), { {QStringLiteral("drive-removable-media-usb-pendrive")}} }, - { QStringLiteral("device-usb-drive"), { {}} }, - { QStringLiteral("device-usb-flash"), { {}} }, - { QStringLiteral("dialog-error"), { {}} }, - { QStringLiteral("dialog-information"), { {}} }, - { QStringLiteral("dialog-ok-apply"), { {}} }, - { QStringLiteral("dialog-password"), { {}} }, - { QStringLiteral("dialog-warning"), { {}} }, - { QStringLiteral("document-download"), { {QStringLiteral("download")}} }, - { QStringLiteral("document-new"), { {}} }, - { QStringLiteral("document-open-folder"), { {}} }, - { QStringLiteral("document-open"), { {}} }, - { QStringLiteral("document-save"), { {}} }, - { QStringLiteral("document-search"), { {}} }, - { QStringLiteral("document-open-remote"), { {}} }, - { QStringLiteral("download"), { {QStringLiteral("applications-internet"), QStringLiteral("network-workgroup")}} }, - { QStringLiteral("edit-clear-list"), { {QStringLiteral("edit-clear-list"), QStringLiteral("edit-clear-all")}} }, - { QStringLiteral("edit-clear-locationbar-ltr"), { {QStringLiteral("edit-clear-locationbar-ltr")}} }, - { QStringLiteral("edit-copy"), { {}} }, - { QStringLiteral("edit-delete"), { {}} }, - { QStringLiteral("edit-find"), { {}} }, - { QStringLiteral("edit-redo"), { {}} }, - { QStringLiteral("edit-rename"), { {}} }, - { QStringLiteral("edit-undo"), { {}} }, - { QStringLiteral("electrocompaniet"), { {}} }, - { QStringLiteral("equalizer"), { {QStringLiteral("view-media-equalizer")}} }, - { QStringLiteral("folder-new"), { {}} }, - { QStringLiteral("folder"), { {}} }, - { QStringLiteral("folder-sound"), { {QStringLiteral("folder-music")}} }, - { QStringLiteral("footsteps"), { {QStringLiteral("go-jump")}} }, - { QStringLiteral("go-down"), { {}} }, - { QStringLiteral("go-home"), { {}} }, - { QStringLiteral("go-jump"), { {}} }, - { QStringLiteral("go-next"), { {}} }, - { QStringLiteral("go-previous"), { {}} }, - { QStringLiteral("go-up"), { {}} }, - { QStringLiteral("gstreamer"), { {QStringLiteral("phonon-gstreamer")}} }, - { QStringLiteral("headset"), { {QStringLiteral("audio-headset")}} }, - { QStringLiteral("help-hint"), { {}} }, - { QStringLiteral("intel"), { {}} }, - { QStringLiteral("jack"), { {QStringLiteral("audio-input-line")}} }, - { QStringLiteral("keyboard"), { {QStringLiteral("input-keyboard")}} }, - { QStringLiteral("list-add"), { {}} }, - { QStringLiteral("list-remove"), { {}} }, - { QStringLiteral("love"), { {QStringLiteral("heart"), QStringLiteral("emblem-favorite")}} }, - { QStringLiteral("mcintosh-player"), { {}} }, - { QStringLiteral("mcintosh"), { {}} }, - { QStringLiteral("mcintosh-text"), { {}} }, - { QStringLiteral("media-eject"), { {}} }, - { QStringLiteral("media-playback-pause"), { {QStringLiteral("media-pause")}} }, - { QStringLiteral("media-playlist-repeat"), { {}} }, - { QStringLiteral("media-playlist-shuffle"), { {""_L1}} }, - { QStringLiteral("media-playback-start"), { {QStringLiteral("media-play"), QStringLiteral("media-playback-playing")}} }, - { QStringLiteral("media-seek-backward"), { {}} }, - { QStringLiteral("media-seek-forward"), { {}} }, - { QStringLiteral("media-skip-backward"), { {}} }, - { QStringLiteral("media-skip-forward"), { {}} }, - { QStringLiteral("media-playback-stop"), { {QStringLiteral("media-stop")}} }, - { QStringLiteral("moodbar"), { {QStringLiteral("preferences-desktop-icons")}} }, - { QStringLiteral("nvidia"), { {}} }, - { QStringLiteral("pulseaudio"), { {}} }, - { QStringLiteral("realtek"), { {}} }, - { QStringLiteral("scrobble-disabled"), { {}} }, - { QStringLiteral("scrobble"), { {QStringLiteral("love")}} }, - { QStringLiteral("search"), { {}} }, - { QStringLiteral("soundcard"), { {QStringLiteral("audiocard"), QStringLiteral("audio-card")}} }, - { QStringLiteral("speaker"), { {}} }, - { QStringLiteral("star-grey"), { {}} }, - { QStringLiteral("star"), { {}} }, - { QStringLiteral("strawberry"), { {}} }, - { QStringLiteral("subsonic"), { {}} }, - { QStringLiteral("tidal"), { {}} }, - { QStringLiteral("tools-wizard"), { {}} }, - { QStringLiteral("view-choose"), { {}} }, - { QStringLiteral("view-fullscreen"), { {}} }, - { QStringLiteral("view-media-lyrics"), { {}} }, - { QStringLiteral("view-media-playlist"), { {}} }, - { QStringLiteral("view-media-visualization"), { {QStringLiteral("preferences-desktop-theme")}} }, - { QStringLiteral("view-refresh"), { {}} }, - { QStringLiteral("library-music"), { {QStringLiteral("vinyl")}} }, - { QStringLiteral("vlc"), { {}} }, - { QStringLiteral("zoom-in"), { {}} }, - { QStringLiteral("zoom-out"), { {}, 0, 0 } } + { u"albums"_s, { {u"media-optical"_s}} }, + { u"alsa"_s, { {}} }, + { u"application-exit"_s, { {}} }, + { u"applications-internet"_s, { {}} }, + { u"bluetooth"_s, { {u"preferences-system-bluetooth"_s, u"bluetooth-active"_s}} }, + { u"cdcase"_s, { {u"cdcover"_s, u"media-optical"_s}} }, + { u"media-optical"_s, { {u"cd"_s}} }, + { u"configure"_s, { {}} }, + { u"device-ipod-nano"_s, { {}} }, + { u"device-ipod"_s, { {}} }, + { u"device-phone"_s, { {}} }, + { u"device"_s, { {u"drive-removable-media-usb-pendrive"_s}} }, + { u"device-usb-drive"_s, { {}} }, + { u"device-usb-flash"_s, { {}} }, + { u"dialog-error"_s, { {}} }, + { u"dialog-information"_s, { {}} }, + { u"dialog-ok-apply"_s, { {}} }, + { u"dialog-password"_s, { {}} }, + { u"dialog-warning"_s, { {}} }, + { u"document-download"_s, { {u"download"_s}} }, + { u"document-new"_s, { {}} }, + { u"document-open-folder"_s, { {}} }, + { u"document-open"_s, { {}} }, + { u"document-save"_s, { {}} }, + { u"document-search"_s, { {}} }, + { u"document-open-remote"_s, { {}} }, + { u"download"_s, { {u"applications-internet"_s, u"network-workgroup"_s}} }, + { u"edit-clear-list"_s, { {u"edit-clear-list"_s, u"edit-clear-all"_s}} }, + { u"edit-clear-locationbar-ltr"_s, { {u"edit-clear-locationbar-ltr"_s}} }, + { u"edit-copy"_s, { {}} }, + { u"edit-delete"_s, { {}} }, + { u"edit-find"_s, { {}} }, + { u"edit-redo"_s, { {}} }, + { u"edit-rename"_s, { {}} }, + { u"edit-undo"_s, { {}} }, + { u"electrocompaniet"_s, { {}} }, + { u"equalizer"_s, { {u"view-media-equalizer"_s}} }, + { u"folder-new"_s, { {}} }, + { u"folder"_s, { {}} }, + { u"folder-sound"_s, { {u"folder-music"_s}} }, + { u"footsteps"_s, { {u"go-jump"_s}} }, + { u"go-down"_s, { {}} }, + { u"go-home"_s, { {}} }, + { u"go-jump"_s, { {}} }, + { u"go-next"_s, { {}} }, + { u"go-previous"_s, { {}} }, + { u"go-up"_s, { {}} }, + { u"gstreamer"_s, { {u"phonon-gstreamer"_s}} }, + { u"headset"_s, { {u"audio-headset"_s}} }, + { u"help-hint"_s, { {}} }, + { u"intel"_s, { {}} }, + { u"jack"_s, { {u"audio-input-line"_s}} }, + { u"keyboard"_s, { {u"input-keyboard"_s}} }, + { u"list-add"_s, { {}} }, + { u"list-remove"_s, { {}} }, + { u"love"_s, { {u"heart"_s, u"emblem-favorite"_s}} }, + { u"mcintosh-player"_s, { {}} }, + { u"mcintosh"_s, { {}} }, + { u"mcintosh-text"_s, { {}} }, + { u"media-eject"_s, { {}} }, + { u"media-playback-pause"_s, { {u"media-pause"_s}} }, + { u"media-playlist-repeat"_s, { {}} }, + { u"media-playlist-shuffle"_s, { {""_L1}} }, + { u"media-playback-start"_s, { {u"media-play"_s, u"media-playback-playing"_s}} }, + { u"media-seek-backward"_s, { {}} }, + { u"media-seek-forward"_s, { {}} }, + { u"media-skip-backward"_s, { {}} }, + { u"media-skip-forward"_s, { {}} }, + { u"media-playback-stop"_s, { {u"media-stop"_s}} }, + { u"moodbar"_s, { {u"preferences-desktop-icons"_s}} }, + { u"nvidia"_s, { {}} }, + { u"pulseaudio"_s, { {}} }, + { u"realtek"_s, { {}} }, + { u"scrobble-disabled"_s, { {}} }, + { u"scrobble"_s, { {u"love"_s}} }, + { u"search"_s, { {}} }, + { u"soundcard"_s, { {u"audiocard"_s, u"audio-card"_s}} }, + { u"speaker"_s, { {}} }, + { u"star-grey"_s, { {}} }, + { u"star"_s, { {}} }, + { u"strawberry"_s, { {}} }, + { u"subsonic"_s, { {}} }, + { u"tidal"_s, { {}} }, + { u"tools-wizard"_s, { {}} }, + { u"view-choose"_s, { {}} }, + { u"view-fullscreen"_s, { {}} }, + { u"view-media-lyrics"_s, { {}} }, + { u"view-media-playlist"_s, { {}} }, + { u"view-media-visualization"_s, { {u"preferences-desktop-theme"_s}} }, + { u"view-refresh"_s, { {}} }, + { u"library-music"_s, { {u"vinyl"_s}} }, + { u"vlc"_s, { {}} }, + { u"zoom-in"_s, { {}} }, + { u"zoom-out"_s, { {}, 0, 0 } } }; } // namespace IconMapper #endif // ICONMAPPER_H - diff --git a/src/core/song.cpp b/src/core/song.cpp index f03dd5d1e..128bc3fa4 100644 --- a/src/core/song.cpp +++ b/src/core/song.cpp @@ -65,116 +65,116 @@ using namespace Qt::StringLiterals; -const QStringList Song::kColumns = QStringList() << QStringLiteral("title") - << QStringLiteral("album") - << QStringLiteral("artist") - << QStringLiteral("albumartist") - << QStringLiteral("track") - << QStringLiteral("disc") - << QStringLiteral("year") - << QStringLiteral("originalyear") - << QStringLiteral("genre") - << QStringLiteral("compilation") - << QStringLiteral("composer") - << QStringLiteral("performer") - << QStringLiteral("grouping") - << QStringLiteral("comment") - << QStringLiteral("lyrics") +const QStringList Song::kColumns = QStringList() << u"title"_s + << u"album"_s + << u"artist"_s + << u"albumartist"_s + << u"track"_s + << u"disc"_s + << u"year"_s + << u"originalyear"_s + << u"genre"_s + << u"compilation"_s + << u"composer"_s + << u"performer"_s + << u"grouping"_s + << u"comment"_s + << u"lyrics"_s - << QStringLiteral("artist_id") - << QStringLiteral("album_id") - << QStringLiteral("song_id") + << u"artist_id"_s + << u"album_id"_s + << u"song_id"_s - << QStringLiteral("beginning") - << QStringLiteral("length") + << u"beginning"_s + << u"length"_s - << QStringLiteral("bitrate") - << QStringLiteral("samplerate") - << QStringLiteral("bitdepth") + << u"bitrate"_s + << u"samplerate"_s + << u"bitdepth"_s - << QStringLiteral("source") - << QStringLiteral("directory_id") - << QStringLiteral("url") - << QStringLiteral("filetype") - << QStringLiteral("filesize") - << QStringLiteral("mtime") - << QStringLiteral("ctime") - << QStringLiteral("unavailable") + << u"source"_s + << u"directory_id"_s + << u"url"_s + << u"filetype"_s + << u"filesize"_s + << u"mtime"_s + << u"ctime"_s + << u"unavailable"_s - << QStringLiteral("fingerprint") + << u"fingerprint"_s - << QStringLiteral("playcount") - << QStringLiteral("skipcount") - << QStringLiteral("lastplayed") - << QStringLiteral("lastseen") + << u"playcount"_s + << u"skipcount"_s + << u"lastplayed"_s + << u"lastseen"_s - << QStringLiteral("compilation_detected") - << QStringLiteral("compilation_on") - << QStringLiteral("compilation_off") - << QStringLiteral("compilation_effective") + << u"compilation_detected"_s + << u"compilation_on"_s + << u"compilation_off"_s + << u"compilation_effective"_s - << QStringLiteral("art_embedded") - << QStringLiteral("art_automatic") - << QStringLiteral("art_manual") - << QStringLiteral("art_unset") + << u"art_embedded"_s + << u"art_automatic"_s + << u"art_manual"_s + << u"art_unset"_s - << QStringLiteral("effective_albumartist") - << QStringLiteral("effective_originalyear") + << u"effective_albumartist"_s + << u"effective_originalyear"_s - << QStringLiteral("cue_path") + << u"cue_path"_s - << QStringLiteral("rating") + << u"rating"_s - << QStringLiteral("acoustid_id") - << QStringLiteral("acoustid_fingerprint") + << u"acoustid_id"_s + << u"acoustid_fingerprint"_s - << QStringLiteral("musicbrainz_album_artist_id") - << QStringLiteral("musicbrainz_artist_id") - << QStringLiteral("musicbrainz_original_artist_id") - << QStringLiteral("musicbrainz_album_id") - << QStringLiteral("musicbrainz_original_album_id") - << QStringLiteral("musicbrainz_recording_id") - << QStringLiteral("musicbrainz_track_id") - << QStringLiteral("musicbrainz_disc_id") - << QStringLiteral("musicbrainz_release_group_id") - << QStringLiteral("musicbrainz_work_id") + << u"musicbrainz_album_artist_id"_s + << u"musicbrainz_artist_id"_s + << u"musicbrainz_original_artist_id"_s + << u"musicbrainz_album_id"_s + << u"musicbrainz_original_album_id"_s + << u"musicbrainz_recording_id"_s + << u"musicbrainz_track_id"_s + << u"musicbrainz_disc_id"_s + << u"musicbrainz_release_group_id"_s + << u"musicbrainz_work_id"_s - << QStringLiteral("ebur128_integrated_loudness_lufs") - << QStringLiteral("ebur128_loudness_range_lu") + << u"ebur128_integrated_loudness_lufs"_s + << u"ebur128_loudness_range_lu"_s ; -const QStringList Song::kRowIdColumns = QStringList() << QStringLiteral("ROWID") << kColumns; +const QStringList Song::kRowIdColumns = QStringList() << u"ROWID"_s << kColumns; const QString Song::kColumnSpec = kColumns.join(", "_L1); const QString Song::kRowIdColumnSpec = kRowIdColumns.join(", "_L1); -const QString Song::kBindSpec = Utilities::Prepend(QStringLiteral(":"), kColumns).join(", "_L1); +const QString Song::kBindSpec = Utilities::Prepend(u":"_s, kColumns).join(", "_L1); const QString Song::kUpdateSpec = Utilities::Updateify(kColumns).join(", "_L1); -const QStringList Song::kTextSearchColumns = QStringList() << QStringLiteral("title") - << QStringLiteral("album") - << QStringLiteral("artist") - << QStringLiteral("albumartist") - << QStringLiteral("composer") - << QStringLiteral("performer") - << QStringLiteral("grouping") - << QStringLiteral("genre") - << QStringLiteral("comment") - << QStringLiteral("filename") - << QStringLiteral("url"); +const QStringList Song::kTextSearchColumns = QStringList() << u"title"_s + << u"album"_s + << u"artist"_s + << u"albumartist"_s + << u"composer"_s + << u"performer"_s + << u"grouping"_s + << u"genre"_s + << u"comment"_s + << u"filename"_s + << u"url"_s; -const QStringList Song::kIntSearchColumns = QStringList() << QStringLiteral("track") - << QStringLiteral("year") - << QStringLiteral("samplerate") - << QStringLiteral("bitdepth") - << QStringLiteral("bitrate"); +const QStringList Song::kIntSearchColumns = QStringList() << u"track"_s + << u"year"_s + << u"samplerate"_s + << u"bitdepth"_s + << u"bitrate"_s; -const QStringList Song::kUIntSearchColumns = QStringList() << QStringLiteral("playcount") - << QStringLiteral("skipcount"); +const QStringList Song::kUIntSearchColumns = QStringList() << u"playcount"_s + << u"skipcount"_s; -const QStringList Song::kInt64SearchColumns = QStringList() << QStringLiteral("length"); +const QStringList Song::kInt64SearchColumns = QStringList() << u"length"_s; -const QStringList Song::kFloatSearchColumns = QStringList() << QStringLiteral("rating"); +const QStringList Song::kFloatSearchColumns = QStringList() << u"rating"_s; const QStringList Song::kNumericalSearchColumns = QStringList() << kIntSearchColumns << kUIntSearchColumns @@ -185,19 +185,19 @@ const QStringList Song::kSearchColumns = QStringList() << kTextSearchColumns << kNumericalSearchColumns; const Song::RegularExpressionList Song::kAlbumDisc = Song::RegularExpressionList() - << QRegularExpression(QStringLiteral("\\s+-*\\s*(Disc|CD)\\s*([0-9]{1,2})$"), QRegularExpression::CaseInsensitiveOption) - << QRegularExpression(QStringLiteral("\\s+-*\\s*\\(\\s*(Disc|CD)\\s*([0-9]{1,2})\\)$"), QRegularExpression::CaseInsensitiveOption) - << QRegularExpression(QStringLiteral("\\s+-*\\s*\\[\\s*(Disc|CD)\\s*([0-9]{1,2})\\]$"), QRegularExpression::CaseInsensitiveOption); + << QRegularExpression(u"\\s+-*\\s*(Disc|CD)\\s*([0-9]{1,2})$"_s, QRegularExpression::CaseInsensitiveOption) + << QRegularExpression(u"\\s+-*\\s*\\(\\s*(Disc|CD)\\s*([0-9]{1,2})\\)$"_s, QRegularExpression::CaseInsensitiveOption) + << QRegularExpression(u"\\s+-*\\s*\\[\\s*(Disc|CD)\\s*([0-9]{1,2})\\]$"_s, QRegularExpression::CaseInsensitiveOption); const Song::RegularExpressionList Song::kRemastered = Song::RegularExpressionList() - << QRegularExpression(QStringLiteral("\\s+-*\\s*(([0-9]{4})*\\s*Remastered|([0-9]{4})*\\s*Remaster)\\s*(Version)*\\s*$"), QRegularExpression::CaseInsensitiveOption) - << QRegularExpression(QStringLiteral("\\s+-*\\s*\\(\\s*(([0-9]{4})*\\s*Remastered|([0-9]{4})*\\s*Remaster)\\s*(Version)*\\s*\\)\\s*$"), QRegularExpression::CaseInsensitiveOption) - << QRegularExpression(QStringLiteral("\\s+-*\\s*\\[\\s*(([0-9]{4})*\\s*Remastered|([0-9]{4})*\\s*Remaster)\\s*(Version)*\\s*\\]\\s*$"), QRegularExpression::CaseInsensitiveOption); + << QRegularExpression(u"\\s+-*\\s*(([0-9]{4})*\\s*Remastered|([0-9]{4})*\\s*Remaster)\\s*(Version)*\\s*$"_s, QRegularExpression::CaseInsensitiveOption) + << QRegularExpression(u"\\s+-*\\s*\\(\\s*(([0-9]{4})*\\s*Remastered|([0-9]{4})*\\s*Remaster)\\s*(Version)*\\s*\\)\\s*$"_s, QRegularExpression::CaseInsensitiveOption) + << QRegularExpression(u"\\s+-*\\s*\\[\\s*(([0-9]{4})*\\s*Remastered|([0-9]{4})*\\s*Remaster)\\s*(Version)*\\s*\\]\\s*$"_s, QRegularExpression::CaseInsensitiveOption); const Song::RegularExpressionList Song::kExplicit = Song::RegularExpressionList() - << QRegularExpression(QStringLiteral("\\s+-*\\s*Explicit\\s*$"), QRegularExpression::CaseInsensitiveOption) - << QRegularExpression(QStringLiteral("\\s+-*\\s*\\(\\s*Explicit\\s*\\)\\s*$"), QRegularExpression::CaseInsensitiveOption) - << QRegularExpression(QStringLiteral("\\s+-*\\s*\\[\\s*Explicit\\s*\\]\\s*$"), QRegularExpression::CaseInsensitiveOption); + << QRegularExpression(u"\\s+-*\\s*Explicit\\s*$"_s, QRegularExpression::CaseInsensitiveOption) + << QRegularExpression(u"\\s+-*\\s*\\(\\s*Explicit\\s*\\)\\s*$"_s, QRegularExpression::CaseInsensitiveOption) + << QRegularExpression(u"\\s+-*\\s*\\[\\s*Explicit\\s*\\]\\s*$"_s, QRegularExpression::CaseInsensitiveOption); const Song::RegularExpressionList Song::kAlbumMisc = Song::RegularExpressionList() << kRemastered @@ -207,47 +207,47 @@ const Song::RegularExpressionList Song::kTitleMisc = Song::RegularExpressionList << kRemastered << kExplicit; -const QStringList Song::kArticles = QStringList() << QStringLiteral("the ") << QStringLiteral("a ") << QStringLiteral("an "); +const QStringList Song::kArticles = QStringList() << u"the "_s << u"a "_s << u"an "_s; -const QStringList Song::kAcceptedExtensions = QStringList() << QStringLiteral("wav") - << QStringLiteral("flac") - << QStringLiteral("wv") - << QStringLiteral("ogg") - << QStringLiteral("oga") - << QStringLiteral("opus") - << QStringLiteral("spx") - << QStringLiteral("ape") - << QStringLiteral("mpc") - << QStringLiteral("mp2") - << QStringLiteral("mp3") - << QStringLiteral("m4a") - << QStringLiteral("mp4") - << QStringLiteral("aac") - << QStringLiteral("asf") - << QStringLiteral("asx") - << QStringLiteral("wma") - << QStringLiteral("aif") - << QStringLiteral("aiff") - << QStringLiteral("mka") - << QStringLiteral("tta") - << QStringLiteral("dsf") - << QStringLiteral("dsd") - << QStringLiteral("ac3") - << QStringLiteral("dts") - << QStringLiteral("spc") - << QStringLiteral("vgm"); +const QStringList Song::kAcceptedExtensions = QStringList() << u"wav"_s + << u"flac"_s + << u"wv"_s + << u"ogg"_s + << u"oga"_s + << u"opus"_s + << u"spx"_s + << u"ape"_s + << u"mpc"_s + << u"mp2"_s + << u"mp3"_s + << u"m4a"_s + << u"mp4"_s + << u"aac"_s + << u"asf"_s + << u"asx"_s + << u"wma"_s + << u"aif"_s + << u"aiff"_s + << u"mka"_s + << u"tta"_s + << u"dsf"_s + << u"dsd"_s + << u"ac3"_s + << u"dts"_s + << u"spc"_s + << u"vgm"_s; -const QStringList Song::kRejectedExtensions = QStringList() << QStringLiteral("tmp") - << QStringLiteral("tar") - << QStringLiteral("gz") - << QStringLiteral("bz2") - << QStringLiteral("xz") - << QStringLiteral("tbz") - << QStringLiteral("tgz") - << QStringLiteral("z") - << QStringLiteral("zip") - << QStringLiteral("rar") - << QStringLiteral("wvc"); +const QStringList Song::kRejectedExtensions = QStringList() << u"tmp"_s + << u"tar"_s + << u"gz"_s + << u"bz2"_s + << u"xz"_s + << u"tbz"_s + << u"tgz"_s + << u"z"_s + << u"zip"_s + << u"rar"_s + << u"wvc"_s; struct Song::Private : public QSharedData { @@ -712,7 +712,7 @@ QString Song::sortable(const QString &v) { for (const auto &i : kArticles) { if (copy.startsWith(i)) { qint64 ilen = i.length(); - return copy.right(copy.length() - ilen) + QStringLiteral(", ") + copy.left(ilen - 1); + return copy.right(copy.length() - ilen) + u", "_s + copy.left(ilen - 1); } } @@ -745,7 +745,7 @@ QString Song::PrettyTitleWithArtist() const { QString title(PrettyTitle()); - if (!d->artist_.isEmpty()) title = d->artist_ + QStringLiteral(" - ") + title; + if (!d->artist_.isEmpty()) title = d->artist_ + u" - "_s + title; return title; @@ -781,7 +781,7 @@ QString Song::TitleWithCompilationArtist() const { if (title.isEmpty()) title = d->basefilename_; - if (is_compilation() && !d->artist_.isEmpty() && !d->artist_.contains("various"_L1, Qt::CaseInsensitive)) title = d->artist_ + QStringLiteral(" - ") + title; + if (is_compilation() && !d->artist_.isEmpty() && !d->artist_.contains("various"_L1, Qt::CaseInsensitive)) title = d->artist_ + u" - "_s + title; return title; @@ -824,7 +824,7 @@ QString Song::PrettyRating() const { float rating = d->rating_; - if (rating == -1.0F) return QStringLiteral("0"); + if (rating == -1.0F) return u"0"_s; return QString::number(static_cast(rating * 100)); @@ -953,12 +953,12 @@ bool Song::IsSimilar(const Song &other) const { Song::Source Song::SourceFromURL(const QUrl &url) { if (url.isLocalFile()) return Source::LocalFile; - if (url.scheme() == QStringLiteral("cdda")) return Source::CDDA; - if (url.scheme() == QStringLiteral("subsonic")) return Source::Subsonic; - if (url.scheme() == QStringLiteral("tidal")) return Source::Tidal; - if (url.scheme() == QStringLiteral("spotify")) return Source::Spotify; - if (url.scheme() == QStringLiteral("qobuz")) return Source::Qobuz; - if (url.scheme() == QStringLiteral("http") || url.scheme() == QStringLiteral("https") || url.scheme() == QStringLiteral("rtsp")) { + if (url.scheme() == u"cdda"_s) return Source::CDDA; + if (url.scheme() == u"subsonic"_s) return Source::Subsonic; + if (url.scheme() == u"tidal"_s) return Source::Tidal; + if (url.scheme() == u"spotify"_s) return Source::Spotify; + if (url.scheme() == u"qobuz"_s) return Source::Qobuz; + if (url.scheme() == u"http"_s || url.scheme() == u"https"_s || url.scheme() == u"rtsp"_s) { if (url.host().endsWith("tidal.com"_L1, Qt::CaseInsensitive)) { return Source::Tidal; } if (url.host().endsWith("spotify.com"_L1, Qt::CaseInsensitive)) { return Source::Spotify; } if (url.host().endsWith("qobuz.com"_L1, Qt::CaseInsensitive)) { return Source::Qobuz; } @@ -973,40 +973,40 @@ Song::Source Song::SourceFromURL(const QUrl &url) { QString Song::TextForSource(const Source source) { switch (source) { - case Source::LocalFile: return QStringLiteral("file"); - case Source::Collection: return QStringLiteral("collection"); - case Source::CDDA: return QStringLiteral("cd"); - case Source::Device: return QStringLiteral("device"); - case Source::Stream: return QStringLiteral("stream"); - case Source::Subsonic: return QStringLiteral("subsonic"); - case Source::Tidal: return QStringLiteral("tidal"); - case Source::Spotify: return QStringLiteral("spotify"); - case Source::Qobuz: return QStringLiteral("qobuz"); - case Source::SomaFM: return QStringLiteral("somafm"); - case Source::RadioParadise: return QStringLiteral("radioparadise"); - case Source::Unknown: return QStringLiteral("unknown"); + case Source::LocalFile: return u"file"_s; + case Source::Collection: return u"collection"_s; + case Source::CDDA: return u"cd"_s; + case Source::Device: return u"device"_s; + case Source::Stream: return u"stream"_s; + case Source::Subsonic: return u"subsonic"_s; + case Source::Tidal: return u"tidal"_s; + case Source::Spotify: return u"spotify"_s; + case Source::Qobuz: return u"qobuz"_s; + case Source::SomaFM: return u"somafm"_s; + case Source::RadioParadise: return u"radioparadise"_s; + case Source::Unknown: return u"unknown"_s; } - return QStringLiteral("unknown"); + return u"unknown"_s; } QString Song::DescriptionForSource(const Source source) { switch (source) { - case Source::LocalFile: return QStringLiteral("File"); - case Source::Collection: return QStringLiteral("Collection"); - case Source::CDDA: return QStringLiteral("CD"); - case Source::Device: return QStringLiteral("Device"); - case Source::Stream: return QStringLiteral("Stream"); - case Source::Subsonic: return QStringLiteral("Subsonic"); - case Source::Tidal: return QStringLiteral("Tidal"); - case Source::Spotify: return QStringLiteral("Spotify"); - case Source::Qobuz: return QStringLiteral("Qobuz"); - case Source::SomaFM: return QStringLiteral("SomaFM"); - case Source::RadioParadise: return QStringLiteral("Radio Paradise"); - case Source::Unknown: return QStringLiteral("Unknown"); + case Source::LocalFile: return u"File"_s; + case Source::Collection: return u"Collection"_s; + case Source::CDDA: return u"CD"_s; + case Source::Device: return u"Device"_s; + case Source::Stream: return u"Stream"_s; + case Source::Subsonic: return u"Subsonic"_s; + case Source::Tidal: return u"Tidal"_s; + case Source::Spotify: return u"Spotify"_s; + case Source::Qobuz: return u"Qobuz"_s; + case Source::SomaFM: return u"SomaFM"_s; + case Source::RadioParadise: return u"Radio Paradise"_s; + case Source::Unknown: return u"Unknown"_s; } - return QStringLiteral("unknown"); + return u"unknown"_s; } @@ -1031,53 +1031,53 @@ Song::Source Song::SourceFromText(const QString &source) { QIcon Song::IconForSource(const Source source) { switch (source) { - case Source::LocalFile: return IconLoader::Load(QStringLiteral("folder-sound")); - case Source::Collection: return IconLoader::Load(QStringLiteral("library-music")); - case Source::CDDA: return IconLoader::Load(QStringLiteral("media-optical")); - case Source::Device: return IconLoader::Load(QStringLiteral("device")); - case Source::Stream: return IconLoader::Load(QStringLiteral("applications-internet")); - case Source::Subsonic: return IconLoader::Load(QStringLiteral("subsonic")); - case Source::Tidal: return IconLoader::Load(QStringLiteral("tidal")); - case Source::Spotify: return IconLoader::Load(QStringLiteral("spotify")); - case Source::Qobuz: return IconLoader::Load(QStringLiteral("qobuz")); - case Source::SomaFM: return IconLoader::Load(QStringLiteral("somafm")); - case Source::RadioParadise: return IconLoader::Load(QStringLiteral("radioparadise")); - case Source::Unknown: return IconLoader::Load(QStringLiteral("edit-delete")); + case Source::LocalFile: return IconLoader::Load(u"folder-sound"_s); + case Source::Collection: return IconLoader::Load(u"library-music"_s); + case Source::CDDA: return IconLoader::Load(u"media-optical"_s); + case Source::Device: return IconLoader::Load(u"device"_s); + case Source::Stream: return IconLoader::Load(u"applications-internet"_s); + case Source::Subsonic: return IconLoader::Load(u"subsonic"_s); + case Source::Tidal: return IconLoader::Load(u"tidal"_s); + case Source::Spotify: return IconLoader::Load(u"spotify"_s); + case Source::Qobuz: return IconLoader::Load(u"qobuz"_s); + case Source::SomaFM: return IconLoader::Load(u"somafm"_s); + case Source::RadioParadise: return IconLoader::Load(u"radioparadise"_s); + case Source::Unknown: return IconLoader::Load(u"edit-delete"_s); } - return IconLoader::Load(QStringLiteral("edit-delete")); + return IconLoader::Load(u"edit-delete"_s); } QString Song::TextForFiletype(const FileType filetype) { switch (filetype) { - case FileType::WAV: return QStringLiteral("Wav"); - case FileType::FLAC: return QStringLiteral("FLAC"); - case FileType::WavPack: return QStringLiteral("WavPack"); - case FileType::OggFlac: return QStringLiteral("Ogg FLAC"); - case FileType::OggVorbis: return QStringLiteral("Ogg Vorbis"); - case FileType::OggOpus: return QStringLiteral("Ogg Opus"); - case FileType::OggSpeex: return QStringLiteral("Ogg Speex"); - case FileType::MPEG: return QStringLiteral("MPEG"); - case FileType::MP4: return QStringLiteral("MP4 AAC"); - case FileType::ASF: return QStringLiteral("Windows Media audio"); - case FileType::AIFF: return QStringLiteral("AIFF"); - case FileType::MPC: return QStringLiteral("MPC"); - case FileType::TrueAudio: return QStringLiteral("TrueAudio"); - case FileType::DSF: return QStringLiteral("DSF"); - case FileType::DSDIFF: return QStringLiteral("DSDIFF"); - case FileType::PCM: return QStringLiteral("PCM"); - case FileType::APE: return QStringLiteral("Monkey's Audio"); + case FileType::WAV: return u"Wav"_s; + case FileType::FLAC: return u"FLAC"_s; + case FileType::WavPack: return u"WavPack"_s; + case FileType::OggFlac: return u"Ogg FLAC"_s; + case FileType::OggVorbis: return u"Ogg Vorbis"_s; + case FileType::OggOpus: return u"Ogg Opus"_s; + case FileType::OggSpeex: return u"Ogg Speex"_s; + case FileType::MPEG: return u"MPEG"_s; + case FileType::MP4: return u"MP4 AAC"_s; + case FileType::ASF: return u"Windows Media audio"_s; + case FileType::AIFF: return u"AIFF"_s; + case FileType::MPC: return u"MPC"_s; + case FileType::TrueAudio: return u"TrueAudio"_s; + case FileType::DSF: return u"DSF"_s; + case FileType::DSDIFF: return u"DSDIFF"_s; + case FileType::PCM: return u"PCM"_s; + case FileType::APE: return u"Monkey's Audio"_s; case FileType::MOD: case FileType::S3M: case FileType::XM: - case FileType::IT: return QStringLiteral("Module Music Format"); - case FileType::CDDA: return QStringLiteral("CDDA"); - case FileType::SPC: return QStringLiteral("SNES SPC700"); - case FileType::VGM: return QStringLiteral("VGM"); - case FileType::Stream: return QStringLiteral("Stream"); + case FileType::IT: return u"Module Music Format"_s; + case FileType::CDDA: return u"CDDA"_s; + case FileType::SPC: return u"SNES SPC700"_s; + case FileType::VGM: return u"VGM"_s; + case FileType::Stream: return u"Stream"_s; case FileType::Unknown: - default: return QObject::tr("Unknown"); + default: return QObject::tr("Unknown"); } } @@ -1085,30 +1085,30 @@ QString Song::TextForFiletype(const FileType filetype) { QString Song::ExtensionForFiletype(const FileType filetype) { switch (filetype) { - case FileType::WAV: return QStringLiteral("wav"); - case FileType::FLAC: return QStringLiteral("flac"); - case FileType::WavPack: return QStringLiteral("wv"); - case FileType::OggFlac: return QStringLiteral("flac"); - case FileType::OggVorbis: return QStringLiteral("ogg"); - case FileType::OggOpus: return QStringLiteral("opus"); - case FileType::OggSpeex: return QStringLiteral("spx"); - case FileType::MPEG: return QStringLiteral("mp3"); - case FileType::MP4: return QStringLiteral("mp4"); - case FileType::ASF: return QStringLiteral("wma"); - case FileType::AIFF: return QStringLiteral("aiff"); - case FileType::MPC: return QStringLiteral("mpc"); - case FileType::TrueAudio: return QStringLiteral("tta"); - case FileType::DSF: return QStringLiteral("dsf"); - case FileType::DSDIFF: return QStringLiteral("dsd"); - case FileType::APE: return QStringLiteral("ape"); - case FileType::MOD: return QStringLiteral("mod"); - case FileType::S3M: return QStringLiteral("s3m"); - case FileType::XM: return QStringLiteral("xm"); - case FileType::IT: return QStringLiteral("it"); - case FileType::SPC: return QStringLiteral("spc"); - case FileType::VGM: return QStringLiteral("vgm"); + case FileType::WAV: return u"wav"_s; + case FileType::FLAC: return u"flac"_s; + case FileType::WavPack: return u"wv"_s; + case FileType::OggFlac: return u"flac"_s; + case FileType::OggVorbis: return u"ogg"_s; + case FileType::OggOpus: return u"opus"_s; + case FileType::OggSpeex: return u"spx"_s; + case FileType::MPEG: return u"mp3"_s; + case FileType::MP4: return u"mp4"_s; + case FileType::ASF: return u"wma"_s; + case FileType::AIFF: return u"aiff"_s; + case FileType::MPC: return u"mpc"_s; + case FileType::TrueAudio: return u"tta"_s; + case FileType::DSF: return u"dsf"_s; + case FileType::DSDIFF: return u"dsd"_s; + case FileType::APE: return u"ape"_s; + case FileType::MOD: return u"mod"_s; + case FileType::S3M: return u"s3m"_s; + case FileType::XM: return u"xm"_s; + case FileType::IT: return u"it"_s; + case FileType::SPC: return u"spc"_s; + case FileType::VGM: return u"vgm"_s; case FileType::Unknown: - default: return QStringLiteral("dat"); + default: return u"dat"_s; } } @@ -1116,31 +1116,31 @@ QString Song::ExtensionForFiletype(const FileType filetype) { QIcon Song::IconForFiletype(const FileType filetype) { switch (filetype) { - case FileType::WAV: return IconLoader::Load(QStringLiteral("wav")); - case FileType::FLAC: return IconLoader::Load(QStringLiteral("flac")); - case FileType::WavPack: return IconLoader::Load(QStringLiteral("wavpack")); - case FileType::OggFlac: return IconLoader::Load(QStringLiteral("flac")); - case FileType::OggVorbis: return IconLoader::Load(QStringLiteral("vorbis")); - case FileType::OggOpus: return IconLoader::Load(QStringLiteral("opus")); - case FileType::OggSpeex: return IconLoader::Load(QStringLiteral("speex")); - case FileType::MPEG: return IconLoader::Load(QStringLiteral("mp3")); - case FileType::MP4: return IconLoader::Load(QStringLiteral("mp4")); - case FileType::ASF: return IconLoader::Load(QStringLiteral("wma")); - case FileType::AIFF: return IconLoader::Load(QStringLiteral("aiff")); - case FileType::MPC: return IconLoader::Load(QStringLiteral("mpc")); - case FileType::TrueAudio: return IconLoader::Load(QStringLiteral("trueaudio")); - case FileType::DSF: return IconLoader::Load(QStringLiteral("dsf")); - case FileType::DSDIFF: return IconLoader::Load(QStringLiteral("dsd")); - case FileType::PCM: return IconLoader::Load(QStringLiteral("pcm")); - case FileType::APE: return IconLoader::Load(QStringLiteral("ape")); - case FileType::MOD: return IconLoader::Load(QStringLiteral("mod")); - case FileType::S3M: return IconLoader::Load(QStringLiteral("s3m")); - case FileType::XM: return IconLoader::Load(QStringLiteral("xm")); - case FileType::IT: return IconLoader::Load(QStringLiteral("it")); - case FileType::CDDA: return IconLoader::Load(QStringLiteral("cd")); - case FileType::Stream: return IconLoader::Load(QStringLiteral("applications-internet")); + case FileType::WAV: return IconLoader::Load(u"wav"_s); + case FileType::FLAC: return IconLoader::Load(u"flac"_s); + case FileType::WavPack: return IconLoader::Load(u"wavpack"_s); + case FileType::OggFlac: return IconLoader::Load(u"flac"_s); + case FileType::OggVorbis: return IconLoader::Load(u"vorbis"_s); + case FileType::OggOpus: return IconLoader::Load(u"opus"_s); + case FileType::OggSpeex: return IconLoader::Load(u"speex"_s); + case FileType::MPEG: return IconLoader::Load(u"mp3"_s); + case FileType::MP4: return IconLoader::Load(u"mp4"_s); + case FileType::ASF: return IconLoader::Load(u"wma"_s); + case FileType::AIFF: return IconLoader::Load(u"aiff"_s); + case FileType::MPC: return IconLoader::Load(u"mpc"_s); + case FileType::TrueAudio: return IconLoader::Load(u"trueaudio"_s); + case FileType::DSF: return IconLoader::Load(u"dsf"_s); + case FileType::DSDIFF: return IconLoader::Load(u"dsd"_s); + case FileType::PCM: return IconLoader::Load(u"pcm"_s); + case FileType::APE: return IconLoader::Load(u"ape"_s); + case FileType::MOD: return IconLoader::Load(u"mod"_s); + case FileType::S3M: return IconLoader::Load(u"s3m"_s); + case FileType::XM: return IconLoader::Load(u"xm"_s); + case FileType::IT: return IconLoader::Load(u"it"_s); + case FileType::CDDA: return IconLoader::Load(u"cd"_s); + case FileType::Stream: return IconLoader::Load(u"applications-internet"_s); case FileType::Unknown: - default: return IconLoader::Load(QStringLiteral("edit-delete")); + default: return IconLoader::Load(u"edit-delete"_s); } } @@ -1254,24 +1254,24 @@ QString Song::ImageCacheDir(const Source source) { switch (source) { case Source::Collection: - return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + QStringLiteral("/collectionalbumcovers"); + return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + u"/collectionalbumcovers"_s; case Source::Subsonic: - return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + QStringLiteral("/subsonicalbumcovers"); + return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + u"/subsonicalbumcovers"_s; case Source::Tidal: - return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + QStringLiteral("/tidalalbumcovers"); + return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + u"/tidalalbumcovers"_s; case Source::Spotify: - return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + QStringLiteral("/spotifyalbumcovers"); + return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + u"/spotifyalbumcovers"_s; case Source::Qobuz: - return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + QStringLiteral("/qobuzalbumcovers"); + return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + u"/qobuzalbumcovers"_s; case Source::Device: - return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + QStringLiteral("/devicealbumcovers"); + return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + u"/devicealbumcovers"_s; case Source::LocalFile: case Source::CDDA: case Source::Stream: case Source::SomaFM: case Source::RadioParadise: case Source::Unknown: - return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + QStringLiteral("/albumcovers"); + return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation) + u"/albumcovers"_s; } return QString(); @@ -1435,76 +1435,76 @@ void Song::InitFromQuery(const QSqlRecord &r, const bool reliable_metadata, cons Q_ASSERT(kRowIdColumns.count() + col <= r.count()); - d->id_ = SqlHelper::ValueToInt(r, ColumnIndex(QStringLiteral("ROWID")) + col); + d->id_ = SqlHelper::ValueToInt(r, ColumnIndex(u"ROWID"_s) + col); - set_title(SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("title")) + col)); - set_album(SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("album")) + col)); - set_artist(SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("artist")) + col)); - set_albumartist(SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("albumartist")) + col)); - d->track_ = SqlHelper::ValueToInt(r, ColumnIndex(QStringLiteral("track")) + col); - d->disc_ = SqlHelper::ValueToInt(r, ColumnIndex(QStringLiteral("disc")) + col); - d->year_ = SqlHelper::ValueToInt(r, ColumnIndex(QStringLiteral("year")) + col); - d->originalyear_ = SqlHelper::ValueToInt(r, ColumnIndex(QStringLiteral("originalyear")) + col); - d->genre_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("genre")) + col); - d->compilation_ = r.value(ColumnIndex(QStringLiteral("compilation")) + col).toBool(); - d->composer_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("composer")) + col); - d->performer_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("performer")) + col); - d->grouping_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("grouping")) + col); - d->comment_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("comment")) + col); - d->lyrics_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("lyrics")) + col); - d->artist_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("artist_id")) + col); - d->album_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("album_id")) + col); - d->song_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("song_id")) + col); - d->beginning_ = r.value(ColumnIndex(QStringLiteral("beginning")) + col).isNull() ? 0 : r.value(ColumnIndex(QStringLiteral("beginning")) + col).toLongLong(); - set_length_nanosec(SqlHelper::ValueToLongLong(r, ColumnIndex(QStringLiteral("length")) + col)); - d->bitrate_ = SqlHelper::ValueToInt(r, ColumnIndex(QStringLiteral("bitrate")) + col); - d->samplerate_ = SqlHelper::ValueToInt(r, ColumnIndex(QStringLiteral("samplerate")) + col); - d->bitdepth_ = SqlHelper::ValueToInt(r, ColumnIndex(QStringLiteral("bitdepth")) + col); - if (!r.value(ColumnIndex(QStringLiteral("ebur128_integrated_loudness_lufs")) + col).isNull()) { - d->ebur128_integrated_loudness_lufs_ = r.value(ColumnIndex(QStringLiteral("ebur128_integrated_loudness_lufs")) + col).toDouble(); + set_title(SqlHelper::ValueToString(r, ColumnIndex(u"title"_s) + col)); + set_album(SqlHelper::ValueToString(r, ColumnIndex(u"album"_s) + col)); + set_artist(SqlHelper::ValueToString(r, ColumnIndex(u"artist"_s) + col)); + set_albumartist(SqlHelper::ValueToString(r, ColumnIndex(u"albumartist"_s) + col)); + d->track_ = SqlHelper::ValueToInt(r, ColumnIndex(u"track"_s) + col); + d->disc_ = SqlHelper::ValueToInt(r, ColumnIndex(u"disc"_s) + col); + d->year_ = SqlHelper::ValueToInt(r, ColumnIndex(u"year"_s) + col); + d->originalyear_ = SqlHelper::ValueToInt(r, ColumnIndex(u"originalyear"_s) + col); + d->genre_ = SqlHelper::ValueToString(r, ColumnIndex(u"genre"_s) + col); + d->compilation_ = r.value(ColumnIndex(u"compilation"_s) + col).toBool(); + d->composer_ = SqlHelper::ValueToString(r, ColumnIndex(u"composer"_s) + col); + d->performer_ = SqlHelper::ValueToString(r, ColumnIndex(u"performer"_s) + col); + d->grouping_ = SqlHelper::ValueToString(r, ColumnIndex(u"grouping"_s) + col); + d->comment_ = SqlHelper::ValueToString(r, ColumnIndex(u"comment"_s) + col); + d->lyrics_ = SqlHelper::ValueToString(r, ColumnIndex(u"lyrics"_s) + col); + d->artist_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"artist_id"_s) + col); + d->album_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"album_id"_s) + col); + d->song_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"song_id"_s) + col); + d->beginning_ = r.value(ColumnIndex(u"beginning"_s) + col).isNull() ? 0 : r.value(ColumnIndex(u"beginning"_s) + col).toLongLong(); + set_length_nanosec(SqlHelper::ValueToLongLong(r, ColumnIndex(u"length"_s) + col)); + d->bitrate_ = SqlHelper::ValueToInt(r, ColumnIndex(u"bitrate"_s) + col); + d->samplerate_ = SqlHelper::ValueToInt(r, ColumnIndex(u"samplerate"_s) + col); + d->bitdepth_ = SqlHelper::ValueToInt(r, ColumnIndex(u"bitdepth"_s) + col); + if (!r.value(ColumnIndex(u"ebur128_integrated_loudness_lufs"_s) + col).isNull()) { + d->ebur128_integrated_loudness_lufs_ = r.value(ColumnIndex(u"ebur128_integrated_loudness_lufs"_s) + col).toDouble(); } - if (!r.value(ColumnIndex(QStringLiteral("ebur128_loudness_range_lu")) + col).isNull()) { - d->ebur128_loudness_range_lu_ = r.value(ColumnIndex(QStringLiteral("ebur128_loudness_range_lu")) + col).toDouble(); + if (!r.value(ColumnIndex(u"ebur128_loudness_range_lu"_s) + col).isNull()) { + d->ebur128_loudness_range_lu_ = r.value(ColumnIndex(u"ebur128_loudness_range_lu"_s) + col).toDouble(); } - d->source_ = static_cast(r.value(ColumnIndex(QStringLiteral("source")) + col).isNull() ? 0 : r.value(ColumnIndex(QStringLiteral("source")) + col).toInt()); - d->directory_id_ = SqlHelper::ValueToInt(r, ColumnIndex(QStringLiteral("directory_id")) + col); - set_url(QUrl::fromEncoded(SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("url")) + col).toUtf8())); + d->source_ = static_cast(r.value(ColumnIndex(u"source"_s) + col).isNull() ? 0 : r.value(ColumnIndex(u"source"_s) + col).toInt()); + d->directory_id_ = SqlHelper::ValueToInt(r, ColumnIndex(u"directory_id"_s) + col); + set_url(QUrl::fromEncoded(SqlHelper::ValueToString(r, ColumnIndex(u"url"_s) + col).toUtf8())); d->basefilename_ = QFileInfo(d->url_.toLocalFile()).fileName(); - d->filetype_ = FileType(r.value(ColumnIndex(QStringLiteral("filetype")) + col).isNull() ? 0 : r.value(ColumnIndex(QStringLiteral("filetype")) + col).toInt()); - d->filesize_ = SqlHelper::ValueToLongLong(r, ColumnIndex(QStringLiteral("filesize")) + col); - d->mtime_ = SqlHelper::ValueToLongLong(r, ColumnIndex(QStringLiteral("mtime")) + col); - d->ctime_ = SqlHelper::ValueToLongLong(r, ColumnIndex(QStringLiteral("ctime")) + col); - d->unavailable_ = r.value(ColumnIndex(QStringLiteral("unavailable")) + col).toBool(); - d->fingerprint_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("fingerprint")) + col); - d->playcount_ = SqlHelper::ValueToUInt(r, ColumnIndex(QStringLiteral("playcount")) + col); - d->skipcount_ = SqlHelper::ValueToUInt(r, ColumnIndex(QStringLiteral("skipcount")) + col); - d->lastplayed_ = SqlHelper::ValueToLongLong(r, ColumnIndex(QStringLiteral("lastplayed")) + col); - d->lastseen_ = SqlHelper::ValueToLongLong(r, ColumnIndex(QStringLiteral("lastseen")) + col); - d->compilation_detected_ = SqlHelper::ValueToBool(r, ColumnIndex(QStringLiteral("compilation_detected")) + col); - d->compilation_on_ = SqlHelper::ValueToBool(r, ColumnIndex(QStringLiteral("compilation_on")) + col); - d->compilation_off_ = SqlHelper::ValueToBool(r, ColumnIndex(QStringLiteral("compilation_off")) + col); + d->filetype_ = FileType(r.value(ColumnIndex(u"filetype"_s) + col).isNull() ? 0 : r.value(ColumnIndex(u"filetype"_s) + col).toInt()); + d->filesize_ = SqlHelper::ValueToLongLong(r, ColumnIndex(u"filesize"_s) + col); + d->mtime_ = SqlHelper::ValueToLongLong(r, ColumnIndex(u"mtime"_s) + col); + d->ctime_ = SqlHelper::ValueToLongLong(r, ColumnIndex(u"ctime"_s) + col); + d->unavailable_ = r.value(ColumnIndex(u"unavailable"_s) + col).toBool(); + d->fingerprint_ = SqlHelper::ValueToString(r, ColumnIndex(u"fingerprint"_s) + col); + d->playcount_ = SqlHelper::ValueToUInt(r, ColumnIndex(u"playcount"_s) + col); + d->skipcount_ = SqlHelper::ValueToUInt(r, ColumnIndex(u"skipcount"_s) + col); + d->lastplayed_ = SqlHelper::ValueToLongLong(r, ColumnIndex(u"lastplayed"_s) + col); + d->lastseen_ = SqlHelper::ValueToLongLong(r, ColumnIndex(u"lastseen"_s) + col); + d->compilation_detected_ = SqlHelper::ValueToBool(r, ColumnIndex(u"compilation_detected"_s) + col); + d->compilation_on_ = SqlHelper::ValueToBool(r, ColumnIndex(u"compilation_on"_s) + col); + d->compilation_off_ = SqlHelper::ValueToBool(r, ColumnIndex(u"compilation_off"_s) + col); - d->art_embedded_ = SqlHelper::ValueToBool(r, ColumnIndex(QStringLiteral("art_embedded")) + col); - d->art_automatic_ = QUrl::fromEncoded(SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("art_automatic")) + col).toUtf8()); - d->art_manual_ = QUrl::fromEncoded(SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("art_manual")) + col).toUtf8()); - d->art_unset_ = SqlHelper::ValueToBool(r, ColumnIndex(QStringLiteral("art_unset")) + col); + d->art_embedded_ = SqlHelper::ValueToBool(r, ColumnIndex(u"art_embedded"_s) + col); + d->art_automatic_ = QUrl::fromEncoded(SqlHelper::ValueToString(r, ColumnIndex(u"art_automatic"_s) + col).toUtf8()); + d->art_manual_ = QUrl::fromEncoded(SqlHelper::ValueToString(r, ColumnIndex(u"art_manual"_s) + col).toUtf8()); + d->art_unset_ = SqlHelper::ValueToBool(r, ColumnIndex(u"art_unset"_s) + col); - d->cue_path_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("cue_path")) + col); - d->rating_ = SqlHelper::ValueToFloat(r, ColumnIndex(QStringLiteral("rating")) + col); + d->cue_path_ = SqlHelper::ValueToString(r, ColumnIndex(u"cue_path"_s) + col); + d->rating_ = SqlHelper::ValueToFloat(r, ColumnIndex(u"rating"_s) + col); - d->acoustid_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("acoustid_id")) + col); - d->acoustid_fingerprint_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("acoustid_fingerprint")) + col); + d->acoustid_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"acoustid_id"_s) + col); + d->acoustid_fingerprint_ = SqlHelper::ValueToString(r, ColumnIndex(u"acoustid_fingerprint"_s) + col); - d->musicbrainz_album_artist_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("musicbrainz_album_artist_id")) + col); - d->musicbrainz_artist_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("musicbrainz_artist_id")) + col); - d->musicbrainz_original_artist_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("musicbrainz_original_artist_id")) + col); - d->musicbrainz_album_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("musicbrainz_album_id")) + col); - d->musicbrainz_original_album_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("musicbrainz_original_album_id")) + col); - d->musicbrainz_recording_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("musicbrainz_recording_id")) + col); - d->musicbrainz_track_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("musicbrainz_track_id")) + col); - d->musicbrainz_disc_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("musicbrainz_disc_id")) + col); - d->musicbrainz_release_group_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("musicbrainz_release_group_id")) + col); - d->musicbrainz_work_id_ = SqlHelper::ValueToString(r, ColumnIndex(QStringLiteral("musicbrainz_work_id")) + col); + d->musicbrainz_album_artist_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"musicbrainz_album_artist_id"_s) + col); + d->musicbrainz_artist_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"musicbrainz_artist_id"_s) + col); + d->musicbrainz_original_artist_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"musicbrainz_original_artist_id"_s) + col); + d->musicbrainz_album_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"musicbrainz_album_id"_s) + col); + d->musicbrainz_original_album_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"musicbrainz_original_album_id"_s) + col); + d->musicbrainz_recording_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"musicbrainz_recording_id"_s) + col); + d->musicbrainz_track_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"musicbrainz_track_id"_s) + col); + d->musicbrainz_disc_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"musicbrainz_disc_id"_s) + col); + d->musicbrainz_release_group_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"musicbrainz_release_group_id"_s) + col); + d->musicbrainz_work_id_ = SqlHelper::ValueToString(r, ColumnIndex(u"musicbrainz_work_id"_s) + col); d->valid_ = true; d->init_from_file_ = reliable_metadata; @@ -1541,7 +1541,7 @@ void Song::InitArtManual() { // If we don't have cover art, check if we have one in the cache if (d->art_manual_.isEmpty() && !effective_albumartist().isEmpty() && !effective_album().isEmpty()) { - QString filename = QString::fromLatin1(CoverUtils::Sha1CoverHash(effective_albumartist(), effective_album()).toHex()) + QStringLiteral(".jpg"); + QString filename = QString::fromLatin1(CoverUtils::Sha1CoverHash(effective_albumartist(), effective_album()).toHex()) + u".jpg"_s; QString path(ImageCacheDir(d->source_) + QLatin1Char('/') + filename); if (QFile::exists(path)) { d->art_manual_ = QUrl::fromLocalFile(path); @@ -1556,7 +1556,7 @@ void Song::InitArtAutomatic() { // Pick the first image file in the album directory. QFileInfo file(d->url_.toLocalFile()); QDir dir(file.path()); - QStringList files = dir.entryList(QStringList() << QStringLiteral("*.jpg") << QStringLiteral("*.png") << QStringLiteral("*.gif") << QStringLiteral("*.jpeg"), QDir::Files|QDir::Readable, QDir::Name); + QStringList files = dir.entryList(QStringList() << u"*.jpg"_s << u"*.png"_s << u"*.gif"_s << u"*.jpeg"_s, QDir::Files|QDir::Readable, QDir::Name); if (files.count() > 0) { d->art_automatic_ = QUrl::fromLocalFile(file.path() + QDir::separator() + files.first()); } @@ -1614,7 +1614,7 @@ void Song::InitFromItdb(Itdb_Track *track, const QString &prefix) { QString cover_path = ImageCacheDir(Source::Device); QDir dir(cover_path); if (!dir.exists()) dir.mkpath(cover_path); - QString cover_file = cover_path + QLatin1Char('/') + QString::fromLatin1(CoverUtils::Sha1CoverHash(effective_albumartist(), effective_album()).toHex()) + QStringLiteral(".jpg"); + QString cover_file = cover_path + QLatin1Char('/') + QString::fromLatin1(CoverUtils::Sha1CoverHash(effective_albumartist(), effective_album()).toHex()) + u".jpg"_s; GError *error = nullptr; if (dir.exists() && gdk_pixbuf_save(pixbuf, cover_file.toUtf8().constData(), "jpeg", &error, nullptr)) { d->art_manual_ = QUrl::fromLocalFile(cover_file); @@ -1755,82 +1755,82 @@ void Song::BindToQuery(SqlQuery *query) const { // Remember to bind these in the same order as kBindSpec - query->BindStringValue(QStringLiteral(":title"), d->title_); - query->BindStringValue(QStringLiteral(":album"), d->album_); - query->BindStringValue(QStringLiteral(":artist"), d->artist_); - query->BindStringValue(QStringLiteral(":albumartist"), d->albumartist_); - query->BindIntValue(QStringLiteral(":track"), d->track_); - query->BindIntValue(QStringLiteral(":disc"), d->disc_); - query->BindIntValue(QStringLiteral(":year"), d->year_); - query->BindIntValue(QStringLiteral(":originalyear"), d->originalyear_); - query->BindStringValue(QStringLiteral(":genre"), d->genre_); - query->BindBoolValue(QStringLiteral(":compilation"), d->compilation_); - query->BindStringValue(QStringLiteral(":composer"), d->composer_); - query->BindStringValue(QStringLiteral(":performer"), d->performer_); - query->BindStringValue(QStringLiteral(":grouping"), d->grouping_); - query->BindStringValue(QStringLiteral(":comment"), d->comment_); - query->BindStringValue(QStringLiteral(":lyrics"), d->lyrics_); + query->BindStringValue(u":title"_s, d->title_); + query->BindStringValue(u":album"_s, d->album_); + query->BindStringValue(u":artist"_s, d->artist_); + query->BindStringValue(u":albumartist"_s, d->albumartist_); + query->BindIntValue(u":track"_s, d->track_); + query->BindIntValue(u":disc"_s, d->disc_); + query->BindIntValue(u":year"_s, d->year_); + query->BindIntValue(u":originalyear"_s, d->originalyear_); + query->BindStringValue(u":genre"_s, d->genre_); + query->BindBoolValue(u":compilation"_s, d->compilation_); + query->BindStringValue(u":composer"_s, d->composer_); + query->BindStringValue(u":performer"_s, d->performer_); + query->BindStringValue(u":grouping"_s, d->grouping_); + query->BindStringValue(u":comment"_s, d->comment_); + query->BindStringValue(u":lyrics"_s, d->lyrics_); - query->BindStringValue(QStringLiteral(":artist_id"), d->artist_id_); - query->BindStringValue(QStringLiteral(":album_id"), d->album_id_); - query->BindStringValue(QStringLiteral(":song_id"), d->song_id_); + query->BindStringValue(u":artist_id"_s, d->artist_id_); + query->BindStringValue(u":album_id"_s, d->album_id_); + query->BindStringValue(u":song_id"_s, d->song_id_); - query->BindValue(QStringLiteral(":beginning"), d->beginning_); - query->BindLongLongValue(QStringLiteral(":length"), length_nanosec()); + query->BindValue(u":beginning"_s, d->beginning_); + query->BindLongLongValue(u":length"_s, length_nanosec()); - query->BindIntValue(QStringLiteral(":bitrate"), d->bitrate_); - query->BindIntValue(QStringLiteral(":samplerate"), d->samplerate_); - query->BindIntValue(QStringLiteral(":bitdepth"), d->bitdepth_); + query->BindIntValue(u":bitrate"_s, d->bitrate_); + query->BindIntValue(u":samplerate"_s, d->samplerate_); + query->BindIntValue(u":bitdepth"_s, d->bitdepth_); - query->BindValue(QStringLiteral(":source"), static_cast(d->source_)); - query->BindNotNullIntValue(QStringLiteral(":directory_id"), d->directory_id_); - query->BindUrlValue(QStringLiteral(":url"), d->url_); - query->BindValue(QStringLiteral(":filetype"), static_cast(d->filetype_)); - query->BindLongLongValueOrZero(QStringLiteral(":filesize"), d->filesize_); - query->BindLongLongValueOrZero(QStringLiteral(":mtime"), d->mtime_); - query->BindLongLongValueOrZero(QStringLiteral(":ctime"), d->ctime_); - query->BindBoolValue(QStringLiteral(":unavailable"), d->unavailable_); + query->BindValue(u":source"_s, static_cast(d->source_)); + query->BindNotNullIntValue(u":directory_id"_s, d->directory_id_); + query->BindUrlValue(u":url"_s, d->url_); + query->BindValue(u":filetype"_s, static_cast(d->filetype_)); + query->BindLongLongValueOrZero(u":filesize"_s, d->filesize_); + query->BindLongLongValueOrZero(u":mtime"_s, d->mtime_); + query->BindLongLongValueOrZero(u":ctime"_s, d->ctime_); + query->BindBoolValue(u":unavailable"_s, d->unavailable_); - query->BindStringValue(QStringLiteral(":fingerprint"), d->fingerprint_); + query->BindStringValue(u":fingerprint"_s, d->fingerprint_); - query->BindValue(QStringLiteral(":playcount"), d->playcount_); - query->BindValue(QStringLiteral(":skipcount"), d->skipcount_); - query->BindLongLongValue(QStringLiteral(":lastplayed"), d->lastplayed_); - query->BindLongLongValue(QStringLiteral(":lastseen"), d->lastseen_); + query->BindValue(u":playcount"_s, d->playcount_); + query->BindValue(u":skipcount"_s, d->skipcount_); + query->BindLongLongValue(u":lastplayed"_s, d->lastplayed_); + query->BindLongLongValue(u":lastseen"_s, d->lastseen_); - query->BindBoolValue(QStringLiteral(":compilation_detected"), d->compilation_detected_); - query->BindBoolValue(QStringLiteral(":compilation_on"), d->compilation_on_); - query->BindBoolValue(QStringLiteral(":compilation_off"), d->compilation_off_); - query->BindBoolValue(QStringLiteral(":compilation_effective"), is_compilation()); + query->BindBoolValue(u":compilation_detected"_s, d->compilation_detected_); + query->BindBoolValue(u":compilation_on"_s, d->compilation_on_); + query->BindBoolValue(u":compilation_off"_s, d->compilation_off_); + query->BindBoolValue(u":compilation_effective"_s, is_compilation()); - query->BindBoolValue(QStringLiteral(":art_embedded"), d->art_embedded_); - query->BindUrlValue(QStringLiteral(":art_automatic"), d->art_automatic_); - query->BindUrlValue(QStringLiteral(":art_manual"), d->art_manual_); - query->BindBoolValue(QStringLiteral(":art_unset"), d->art_unset_); + query->BindBoolValue(u":art_embedded"_s, d->art_embedded_); + query->BindUrlValue(u":art_automatic"_s, d->art_automatic_); + query->BindUrlValue(u":art_manual"_s, d->art_manual_); + query->BindBoolValue(u":art_unset"_s, d->art_unset_); - query->BindStringValue(QStringLiteral(":effective_albumartist"), effective_albumartist()); - query->BindIntValue(QStringLiteral(":effective_originalyear"), effective_originalyear()); + query->BindStringValue(u":effective_albumartist"_s, effective_albumartist()); + query->BindIntValue(u":effective_originalyear"_s, effective_originalyear()); - query->BindValue(QStringLiteral(":cue_path"), d->cue_path_); + query->BindValue(u":cue_path"_s, d->cue_path_); - query->BindFloatValue(QStringLiteral(":rating"), d->rating_); + query->BindFloatValue(u":rating"_s, d->rating_); - query->BindStringValue(QStringLiteral(":acoustid_id"), d->acoustid_id_); - query->BindStringValue(QStringLiteral(":acoustid_fingerprint"), d->acoustid_fingerprint_); + query->BindStringValue(u":acoustid_id"_s, d->acoustid_id_); + query->BindStringValue(u":acoustid_fingerprint"_s, d->acoustid_fingerprint_); - query->BindStringValue(QStringLiteral(":musicbrainz_album_artist_id"), d->musicbrainz_album_artist_id_); - query->BindStringValue(QStringLiteral(":musicbrainz_artist_id"), d->musicbrainz_artist_id_); - query->BindStringValue(QStringLiteral(":musicbrainz_original_artist_id"), d->musicbrainz_original_artist_id_); - query->BindStringValue(QStringLiteral(":musicbrainz_album_id"), d->musicbrainz_album_id_); - query->BindStringValue(QStringLiteral(":musicbrainz_original_album_id"), d->musicbrainz_original_album_id_); - query->BindStringValue(QStringLiteral(":musicbrainz_recording_id"), d->musicbrainz_recording_id_); - query->BindStringValue(QStringLiteral(":musicbrainz_track_id"), d->musicbrainz_track_id_); - query->BindStringValue(QStringLiteral(":musicbrainz_disc_id"), d->musicbrainz_disc_id_); - query->BindStringValue(QStringLiteral(":musicbrainz_release_group_id"), d->musicbrainz_release_group_id_); - query->BindStringValue(QStringLiteral(":musicbrainz_work_id"), d->musicbrainz_work_id_); + query->BindStringValue(u":musicbrainz_album_artist_id"_s, d->musicbrainz_album_artist_id_); + query->BindStringValue(u":musicbrainz_artist_id"_s, d->musicbrainz_artist_id_); + query->BindStringValue(u":musicbrainz_original_artist_id"_s, d->musicbrainz_original_artist_id_); + query->BindStringValue(u":musicbrainz_album_id"_s, d->musicbrainz_album_id_); + query->BindStringValue(u":musicbrainz_original_album_id"_s, d->musicbrainz_original_album_id_); + query->BindStringValue(u":musicbrainz_recording_id"_s, d->musicbrainz_recording_id_); + query->BindStringValue(u":musicbrainz_track_id"_s, d->musicbrainz_track_id_); + query->BindStringValue(u":musicbrainz_disc_id"_s, d->musicbrainz_disc_id_); + query->BindStringValue(u":musicbrainz_release_group_id"_s, d->musicbrainz_release_group_id_); + query->BindStringValue(u":musicbrainz_work_id"_s, d->musicbrainz_work_id_); - query->BindDoubleOrNullValue(QStringLiteral(":ebur128_integrated_loudness_lufs"), d->ebur128_integrated_loudness_lufs_); - query->BindDoubleOrNullValue(QStringLiteral(":ebur128_loudness_range_lu"), d->ebur128_loudness_range_lu_); + query->BindDoubleOrNullValue(u":ebur128_integrated_loudness_lufs"_s, d->ebur128_integrated_loudness_lufs_); + query->BindDoubleOrNullValue(u":ebur128_loudness_range_lu"_s, d->ebur128_loudness_range_lu_); } @@ -1841,23 +1841,23 @@ void Song::ToXesam(QVariantMap *map) const { using mpris::AddMetadataAsList; using mpris::AsMPRISDateTimeType; - AddMetadata(QStringLiteral("xesam:url"), effective_stream_url().toString(), map); - AddMetadata(QStringLiteral("xesam:title"), PrettyTitle(), map); - AddMetadataAsList(QStringLiteral("xesam:artist"), artist(), map); - AddMetadata(QStringLiteral("xesam:album"), album(), map); - AddMetadataAsList(QStringLiteral("xesam:albumArtist"), albumartist(), map); - AddMetadata(QStringLiteral("mpris:length"), (length_nanosec() / kNsecPerUsec), map); - AddMetadata(QStringLiteral("xesam:trackNumber"), track(), map); - AddMetadataAsList(QStringLiteral("xesam:genre"), genre(), map); - AddMetadata(QStringLiteral("xesam:discNumber"), disc(), map); - AddMetadataAsList(QStringLiteral("xesam:comment"), comment(), map); - AddMetadata(QStringLiteral("xesam:contentCreated"), AsMPRISDateTimeType(ctime()), map); - AddMetadata(QStringLiteral("xesam:lastUsed"), AsMPRISDateTimeType(lastplayed()), map); - AddMetadataAsList(QStringLiteral("xesam:composer"), composer(), map); - AddMetadata(QStringLiteral("xesam:useCount"), static_cast(playcount()), map); + AddMetadata(u"xesam:url"_s, effective_stream_url().toString(), map); + AddMetadata(u"xesam:title"_s, PrettyTitle(), map); + AddMetadataAsList(u"xesam:artist"_s, artist(), map); + AddMetadata(u"xesam:album"_s, album(), map); + AddMetadataAsList(u"xesam:albumArtist"_s, albumartist(), map); + AddMetadata(u"mpris:length"_s, (length_nanosec() / kNsecPerUsec), map); + AddMetadata(u"xesam:trackNumber"_s, track(), map); + AddMetadataAsList(u"xesam:genre"_s, genre(), map); + AddMetadata(u"xesam:discNumber"_s, disc(), map); + AddMetadataAsList(u"xesam:comment"_s, comment(), map); + AddMetadata(u"xesam:contentCreated"_s, AsMPRISDateTimeType(ctime()), map); + AddMetadata(u"xesam:lastUsed"_s, AsMPRISDateTimeType(lastplayed()), map); + AddMetadataAsList(u"xesam:composer"_s, composer(), map); + AddMetadata(u"xesam:useCount"_s, static_cast(playcount()), map); if (rating() != -1.0) { - AddMetadata(QStringLiteral("xesam:userRating"), rating(), map); + AddMetadata(u"xesam:userRating"_s, rating(), map); } } @@ -1937,7 +1937,7 @@ void Song::MergeUserSetData(const Song &other, const bool merge_playcount, const } QString Song::AlbumKey() const { - return QStringLiteral("%1|%2|%3").arg(is_compilation() ? QStringLiteral("_compilation") : effective_albumartist(), has_cue() ? cue_path() : ""_L1, effective_album()); + return QStringLiteral("%1|%2|%3").arg(is_compilation() ? u"_compilation"_s : effective_albumartist(), has_cue() ? cue_path() : ""_L1, effective_album()); } size_t qHash(const Song &song) { diff --git a/src/organize/organizeformat.cpp b/src/organize/organizeformat.cpp index 41bc0b9af..df359b92d 100644 --- a/src/organize/organizeformat.cpp +++ b/src/organize/organizeformat.cpp @@ -41,29 +41,29 @@ using namespace Qt::StringLiterals; const char OrganizeFormat::kBlockPattern[] = "\\{([^{}]+)\\}"; const char OrganizeFormat::kTagPattern[] = "\\%([a-zA-Z]*)"; -const QStringList OrganizeFormat::kKnownTags = QStringList() << QStringLiteral("title") - << QStringLiteral("album") - << QStringLiteral("artist") - << QStringLiteral("artistinitial") - << QStringLiteral("albumartist") - << QStringLiteral("composer") - << QStringLiteral("track") - << QStringLiteral("disc") - << QStringLiteral("year") - << QStringLiteral("originalyear") - << QStringLiteral("genre") - << QStringLiteral("comment") - << QStringLiteral("length") - << QStringLiteral("bitrate") - << QStringLiteral("samplerate") - << QStringLiteral("bitdepth") - << QStringLiteral("extension") - << QStringLiteral("performer") - << QStringLiteral("grouping") - << QStringLiteral("lyrics"); +const QStringList OrganizeFormat::kKnownTags = QStringList() << u"title"_s + << u"album"_s + << u"artist"_s + << u"artistinitial"_s + << u"albumartist"_s + << u"composer"_s + << u"track"_s + << u"disc"_s + << u"year"_s + << u"originalyear"_s + << u"genre"_s + << u"comment"_s + << u"length"_s + << u"bitrate"_s + << u"samplerate"_s + << u"bitdepth"_s + << u"extension"_s + << u"performer"_s + << u"grouping"_s + << u"lyrics"_s; -const QStringList OrganizeFormat::kUniqueTags = QStringList() << QStringLiteral("title") - << QStringLiteral("track"); +const QStringList OrganizeFormat::kUniqueTags = QStringList() << u"title"_s + << u"track"_s; OrganizeFormat::OrganizeFormat(const QString &format) : format_(format), @@ -184,12 +184,12 @@ OrganizeFormat::GetFilenameForSongResult OrganizeFormat::GetFilenameForSong(cons filepath = parts_new.join(u'/'); if (replace_spaces_) { - static const QRegularExpression regex_whitespaces(QStringLiteral("\\s")); - filepath.replace(regex_whitespaces, QStringLiteral("_")); + static const QRegularExpression regex_whitespaces(u"\\s"_s); + filepath.replace(regex_whitespaces, u"_"_s); } if (!extension.isEmpty()) { - filepath.append(QStringLiteral(".%1").arg(extension)); + filepath.append(u".%1"_s.arg(extension)); } return GetFilenameForSongResult(filepath, unique_filename); @@ -302,13 +302,13 @@ QString OrganizeFormat::TagValue(const QString &tag, const Song &song) const { else if (tag == "artistinitial"_L1) { value = song.effective_albumartist().trimmed(); if (!value.isEmpty()) { - static const QRegularExpression regex_the(QStringLiteral("^the\\s+"), QRegularExpression::CaseInsensitiveOption); + static const QRegularExpression regex_the(u"^the\\s+"_s, QRegularExpression::CaseInsensitiveOption); value = value.remove(regex_the); value = value[0].toUpper(); } } else if (tag == "albumartist"_L1) { - value = song.is_compilation() ? QStringLiteral("Various Artists") : song.effective_albumartist(); + value = song.is_compilation() ? u"Various Artists"_s : song.effective_albumartist(); } if (value == u'0' || value == "-1"_L1) value = ""_L1; diff --git a/src/scrobbler/scrobblingapi20.cpp b/src/scrobbler/scrobblingapi20.cpp index 150ad5ab9..735c8a1e3 100644 --- a/src/scrobbler/scrobblingapi20.cpp +++ b/src/scrobbler/scrobblingapi20.cpp @@ -209,8 +209,8 @@ void ScrobblingAPI20::Authenticate() { } QUrlQuery url_query; - url_query.addQueryItem(QStringLiteral("api_key"), QLatin1String(kApiKey)); - url_query.addQueryItem(QStringLiteral("cb"), server_->url().toString()); + url_query.addQueryItem(u"api_key"_s, QLatin1String(kApiKey)); + url_query.addQueryItem(u"cb"_s, server_->url().toString()); QUrl url(auth_url_); url.setQuery(url_query); @@ -252,8 +252,8 @@ void ScrobblingAPI20::RedirectArrived() { QUrl url = server_->request_url(); if (url.isValid()) { QUrlQuery url_query(url); - if (url_query.hasQueryItem(QStringLiteral("token"))) { - QString token = url_query.queryItemValue(QStringLiteral("token")); + if (url_query.hasQueryItem(u"token"_s)) { + QString token = url_query.queryItemValue(u"token"_s); RequestSession(token); } else { @@ -278,9 +278,9 @@ void ScrobblingAPI20::RequestSession(const QString &token) { QUrl session_url(api_url_); QUrlQuery session_url_query; - session_url_query.addQueryItem(QStringLiteral("api_key"), QLatin1String(kApiKey)); - session_url_query.addQueryItem(QStringLiteral("method"), QStringLiteral("auth.getSession")); - session_url_query.addQueryItem(QStringLiteral("token"), token); + session_url_query.addQueryItem(u"api_key"_s, QLatin1String(kApiKey)); + session_url_query.addQueryItem(u"method"_s, u"auth.getSession"_s); + session_url_query.addQueryItem(u"token"_s, token); QString data_to_sign; const ParamList params = session_url_query.queryItems(); for (const Param ¶m : params) { @@ -289,8 +289,8 @@ void ScrobblingAPI20::RequestSession(const QString &token) { data_to_sign += QLatin1String(kSecret); QByteArray const digest = QCryptographicHash::hash(data_to_sign.toUtf8(), QCryptographicHash::Md5); const QString signature = QString::fromLatin1(digest.toHex()).rightJustified(32, u'0').toLower(); - session_url_query.addQueryItem(QStringLiteral("api_sig"), signature); - session_url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(QStringLiteral("format"))), QString::fromLatin1(QUrl::toPercentEncoding(QStringLiteral("json")))); + session_url_query.addQueryItem(u"api_sig"_s, signature); + session_url_query.addQueryItem(QString::fromLatin1(QUrl::toPercentEncoding(u"format"_s)), QString::fromLatin1(QUrl::toPercentEncoding(u"json"_s))); session_url.setQuery(session_url_query); QNetworkRequest req(session_url); @@ -316,22 +316,22 @@ void ScrobblingAPI20::AuthenticateReplyFinished(QNetworkReply *reply) { } if (!json_obj.contains("session"_L1)) { - AuthError(QStringLiteral("Json reply from server is missing session.")); + AuthError(u"Json reply from server is missing session."_s); return; } QJsonValue json_session = json_obj["session"_L1]; if (!json_session.isObject()) { - AuthError(QStringLiteral("Json session is not an object.")); + AuthError(u"Json session is not an object."_s); return; } json_obj = json_session.toObject(); if (json_obj.isEmpty()) { - AuthError(QStringLiteral("Json session object is empty.")); + AuthError(u"Json session object is empty."_s); return; } if (!json_obj.contains("subscriber"_L1) || !json_obj.contains("name"_L1) || !json_obj.contains("key"_L1)) { - AuthError(QStringLiteral("Json session object is missing values.")); + AuthError(u"Json session object is missing values."_s); return; } @@ -355,9 +355,9 @@ void ScrobblingAPI20::AuthenticateReplyFinished(QNetworkReply *reply) { QNetworkReply *ScrobblingAPI20::CreateRequest(const ParamList &request_params) { ParamList params = ParamList() - << Param(QStringLiteral("api_key"), QLatin1String(kApiKey)) - << Param(QStringLiteral("sk"), session_key_) - << Param(QStringLiteral("lang"), QLocale().name().left(2).toLower()) + << Param(u"api_key"_s, QLatin1String(kApiKey)) + << Param(u"sk"_s, session_key_) + << Param(u"lang"_s, QLocale().name().left(2).toLower()) << request_params; std::sort(params.begin(), params.end()); @@ -374,13 +374,13 @@ QNetworkReply *ScrobblingAPI20::CreateRequest(const ParamList &request_params) { QByteArray const digest = QCryptographicHash::hash(data_to_sign.toUtf8(), QCryptographicHash::Md5); const QString signature = QString::fromLatin1(digest.toHex()).rightJustified(32, u'0').toLower(); - url_query.addQueryItem(QStringLiteral("api_sig"), QString::fromLatin1(QUrl::toPercentEncoding(signature))); - url_query.addQueryItem(QStringLiteral("format"), QStringLiteral("json")); + url_query.addQueryItem(u"api_sig"_s, QString::fromLatin1(QUrl::toPercentEncoding(signature))); + url_query.addQueryItem(u"format"_s, u"json"_s); QUrl url(api_url_); QNetworkRequest req(url); req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy); - req.setHeader(QNetworkRequest::ContentTypeHeader, QStringLiteral("application/x-www-form-urlencoded")); + req.setHeader(QNetworkRequest::ContentTypeHeader, u"application/x-www-form-urlencoded"_s); QByteArray query = url_query.toString(QUrl::FullyEncoded).toUtf8(); QNetworkReply *reply = network_->post(req, query); replies_ << reply; @@ -402,16 +402,16 @@ void ScrobblingAPI20::UpdateNowPlaying(const Song &song) { if (!authenticated() || !song.is_metadata_good() || settings_->offline()) return; ParamList params = ParamList() - << Param(QStringLiteral("method"), QStringLiteral("track.updateNowPlaying")) - << Param(QStringLiteral("artist"), prefer_albumartist_ ? song.effective_albumartist() : song.artist()) - << Param(QStringLiteral("track"), StripTitle(song.title())); + << Param(u"method"_s, u"track.updateNowPlaying"_s) + << Param(u"artist"_s, prefer_albumartist_ ? song.effective_albumartist() : song.artist()) + << Param(u"track"_s, StripTitle(song.title())); if (!song.album().isEmpty()) { - params << Param(QStringLiteral("album"), StripAlbum(song.album())); + params << Param(u"album"_s, StripAlbum(song.album())); } if (!prefer_albumartist_ && !song.albumartist().isEmpty()) { - params << Param(QStringLiteral("albumArtist"), song.albumartist()); + params << Param(u"albumArtist"_s, song.albumartist()); } QNetworkReply *reply = CreateRequest(params); @@ -434,7 +434,7 @@ void ScrobblingAPI20::UpdateNowPlayingRequestFinished(QNetworkReply *reply) { } if (!json_obj.contains("nowplaying"_L1)) { - Error(QStringLiteral("Json reply from server is missing nowplaying."), json_obj); + Error(u"Json reply from server is missing nowplaying."_s, json_obj); return; } @@ -494,7 +494,7 @@ void ScrobblingAPI20::Submit() { qLog(Debug) << name_ << "Submitting scrobbles."; - ParamList params = ParamList() << Param(QStringLiteral("method"), QStringLiteral("track.scrobble")); + ParamList params = ParamList() << Param(u"method"_s, u"track.scrobble"_s); int i = 0; const ScrobblerCacheItemPtrList all_cache_items = cache_->List(); @@ -507,18 +507,18 @@ void ScrobblingAPI20::Submit() { continue; } cache_items_sent << cache_item; - params << Param(QStringLiteral("%1[%2]").arg(QStringLiteral("artist")).arg(i), prefer_albumartist_ ? cache_item->metadata.effective_albumartist() : cache_item->metadata.artist); - params << Param(QStringLiteral("%1[%2]").arg(QStringLiteral("track")).arg(i), StripTitle(cache_item->metadata.title)); - params << Param(QStringLiteral("%1[%2]").arg(QStringLiteral("timestamp")).arg(i), QString::number(cache_item->timestamp)); - params << Param(QStringLiteral("%1[%2]").arg(QStringLiteral("duration")).arg(i), QString::number(cache_item->metadata.length_nanosec / kNsecPerSec)); + params << Param(u"%1[%2]"_s.arg(u"artist"_s).arg(i), prefer_albumartist_ ? cache_item->metadata.effective_albumartist() : cache_item->metadata.artist); + params << Param(u"%1[%2]"_s.arg(u"track"_s).arg(i), StripTitle(cache_item->metadata.title)); + params << Param(u"%1[%2]"_s.arg(u"timestamp"_s).arg(i), QString::number(cache_item->timestamp)); + params << Param(u"%1[%2]"_s.arg(u"duration"_s).arg(i), QString::number(cache_item->metadata.length_nanosec / kNsecPerSec)); if (!cache_item->metadata.album.isEmpty()) { - params << Param(QStringLiteral("%1[%2]").arg("album"_L1).arg(i), StripAlbum(cache_item->metadata.album)); + params << Param(u"%1[%2]"_s.arg("album"_L1).arg(i), StripAlbum(cache_item->metadata.album)); } if (!prefer_albumartist_ && !cache_item->metadata.albumartist.isEmpty()) { - params << Param(QStringLiteral("%1[%2]").arg("albumArtist"_L1).arg(i), cache_item->metadata.albumartist); + params << Param(u"%1[%2]"_s.arg("albumArtist"_L1).arg(i), cache_item->metadata.albumartist); } if (cache_item->metadata.track > 0) { - params << Param(QStringLiteral("%1[%2]").arg("trackNumber"_L1).arg(i), QString::number(cache_item->metadata.track)); + params << Param(u"%1[%2]"_s.arg("trackNumber"_L1).arg(i), QString::number(cache_item->metadata.track)); } ++i; if (cache_items_sent.count() >= kScrobblesPerRequest) break; @@ -556,43 +556,43 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac submit_error_ = false; if (!json_obj.contains("scrobbles"_L1)) { - Error(QStringLiteral("Json reply from server is missing scrobbles."), json_obj); + Error(u"Json reply from server is missing scrobbles."_s, json_obj); StartSubmit(); return; } QJsonValue value_scrobbles = json_obj["scrobbles"_L1]; if (!value_scrobbles.isObject()) { - Error(QStringLiteral("Json scrobbles is not an object."), json_obj); + Error(u"Json scrobbles is not an object."_s, json_obj); StartSubmit(); return; } json_obj = value_scrobbles.toObject(); if (json_obj.isEmpty()) { - Error(QStringLiteral("Json scrobbles object is empty."), value_scrobbles); + Error(u"Json scrobbles object is empty."_s, value_scrobbles); StartSubmit(); return; } if (!json_obj.contains("@attr"_L1) || !json_obj.contains("scrobble"_L1)) { - Error(QStringLiteral("Json scrobbles object is missing values."), json_obj); + Error(u"Json scrobbles object is missing values."_s, json_obj); StartSubmit(); return; } QJsonValue value_attr = json_obj["@attr"_L1]; if (!value_attr.isObject()) { - Error(QStringLiteral("Json scrobbles attr is not an object."), value_attr); + Error(u"Json scrobbles attr is not an object."_s, value_attr); StartSubmit(); return; } QJsonObject obj_attr = value_attr.toObject(); if (obj_attr.isEmpty()) { - Error(QStringLiteral("Json scrobbles attr is empty."), value_attr); + Error(u"Json scrobbles attr is empty."_s, value_attr); StartSubmit(); return; } if (!obj_attr.contains("accepted"_L1) || !obj_attr.contains("ignored"_L1)) { - Error(QStringLiteral("Json scrobbles attr is missing values."), obj_attr); + Error(u"Json scrobbles attr is missing values."_s, obj_attr); StartSubmit(); return; } @@ -607,7 +607,7 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac if (value_scrobble.isObject()) { QJsonObject obj_scrobble = value_scrobble.toObject(); if (obj_scrobble.isEmpty()) { - Error(QStringLiteral("Json scrobbles scrobble object is empty."), obj_scrobble); + Error(u"Json scrobbles scrobble object is empty."_s, obj_scrobble); StartSubmit(); return; } @@ -616,13 +616,13 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac else if (value_scrobble.isArray()) { array_scrobble = value_scrobble.toArray(); if (array_scrobble.isEmpty()) { - Error(QStringLiteral("Json scrobbles scrobble array is empty."), value_scrobble); + Error(u"Json scrobbles scrobble array is empty."_s, value_scrobble); StartSubmit(); return; } } else { - Error(QStringLiteral("Json scrobbles scrobble is not an object or array."), value_scrobble); + Error(u"Json scrobbles scrobble is not an object or array."_s, value_scrobble); StartSubmit(); return; } @@ -630,7 +630,7 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac for (const QJsonValue &value : std::as_const(array_scrobble)) { if (!value.isObject()) { - Error(QStringLiteral("Json scrobbles scrobble array value is not an object.")); + Error(u"Json scrobbles scrobble array value is not an object."_s); continue; } QJsonObject json_track = value.toObject(); @@ -645,7 +645,7 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac !json_track.contains("timestamp"_L1) || !json_track.contains("ignoredMessage"_L1) ) { - Error(QStringLiteral("Json scrobbles scrobble is missing values."), json_track); + Error(u"Json scrobbles scrobble is missing values."_s, json_track); continue; } @@ -653,10 +653,10 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac QJsonValue value_album = json_track["album"_L1]; QJsonValue value_song = json_track["track"_L1]; QJsonValue value_ignoredmessage = json_track["ignoredMessage"_L1]; - //quint64 timestamp = json_track[QLatin1String("timestamp")].toVariant().toULongLong(); + //quint64 timestamp = json_track[u"timestamp"_s].toVariant().toULongLong(); if (!value_artist.isObject() || !value_album.isObject() || !value_song.isObject() || !value_ignoredmessage.isObject()) { - Error(QStringLiteral("Json scrobbles scrobble values are not objects."), json_track); + Error(u"Json scrobbles scrobble values are not objects."_s, json_track); continue; } @@ -666,7 +666,7 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac QJsonObject obj_ignoredmessage = value_ignoredmessage.toObject(); if (obj_artist.isEmpty() || obj_album.isEmpty() || obj_song.isEmpty() || obj_ignoredmessage.isEmpty()) { - Error(QStringLiteral("Json scrobbles scrobble values objects are empty."), json_track); + Error(u"Json scrobbles scrobble values objects are empty."_s, json_track); continue; } @@ -681,7 +681,7 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac QString ignoredmessage_text = obj_ignoredmessage["#text"_L1].toString(); if (ignoredmessage) { - Error(QStringLiteral("Scrobble for \"%1\" ignored: %2").arg(song, ignoredmessage_text)); + Error(u"Scrobble for \"%1\" ignored: %2"_s.arg(song, ignoredmessage_text)); } else { qLog(Debug) << name_ << "Scrobble for" << song << "accepted"; @@ -696,20 +696,20 @@ void ScrobblingAPI20::ScrobbleRequestFinished(QNetworkReply *reply, ScrobblerCac void ScrobblingAPI20::SendSingleScrobble(ScrobblerCacheItemPtr item) { ParamList params = ParamList() - << Param(QStringLiteral("method"), QStringLiteral("track.scrobble")) - << Param(QStringLiteral("artist"), prefer_albumartist_ ? item->metadata.effective_albumartist() : item->metadata.artist) - << Param(QStringLiteral("track"), StripTitle(item->metadata.title)) - << Param(QStringLiteral("timestamp"), QString::number(item->timestamp)) - << Param(QStringLiteral("duration"), QString::number(item->metadata.length_nanosec / kNsecPerSec)); + << Param(u"method"_s, u"track.scrobble"_s) + << Param(u"artist"_s, prefer_albumartist_ ? item->metadata.effective_albumartist() : item->metadata.artist) + << Param(u"track"_s, StripTitle(item->metadata.title)) + << Param(u"timestamp"_s, QString::number(item->timestamp)) + << Param(u"duration"_s, QString::number(item->metadata.length_nanosec / kNsecPerSec)); if (!item->metadata.album.isEmpty()) { - params << Param(QStringLiteral("album"), StripAlbum(item->metadata.album)); + params << Param(u"album"_s, StripAlbum(item->metadata.album)); } if (!prefer_albumartist_ && !item->metadata.albumartist.isEmpty()) { - params << Param(QStringLiteral("albumArtist"), item->metadata.albumartist); + params << Param(u"albumArtist"_s, item->metadata.albumartist); } if (item->metadata.track > 0) { - params << Param(QStringLiteral("trackNumber"), QString::number(item->metadata.track)); + params << Param(u"trackNumber"_s, QString::number(item->metadata.track)); } QNetworkReply *reply = CreateRequest(params); @@ -733,7 +733,7 @@ void ScrobblingAPI20::SingleScrobbleRequestFinished(QNetworkReply *reply, Scrobb } if (!json_obj.contains("scrobbles"_L1)) { - Error(QStringLiteral("Json reply from server is missing scrobbles."), json_obj); + Error(u"Json reply from server is missing scrobbles."_s, json_obj); cache_item->sent = false; return; } @@ -742,48 +742,48 @@ void ScrobblingAPI20::SingleScrobbleRequestFinished(QNetworkReply *reply, Scrobb QJsonValue value_scrobbles = json_obj["scrobbles"_L1]; if (!value_scrobbles.isObject()) { - Error(QStringLiteral("Json scrobbles is not an object."), json_obj); + Error(u"Json scrobbles is not an object."_s, json_obj); return; } json_obj = value_scrobbles.toObject(); if (json_obj.isEmpty()) { - Error(QStringLiteral("Json scrobbles object is empty."), value_scrobbles); + Error(u"Json scrobbles object is empty."_s, value_scrobbles); return; } if (!json_obj.contains("@attr"_L1) || !json_obj.contains("scrobble"_L1)) { - Error(QStringLiteral("Json scrobbles object is missing values."), json_obj); + Error(u"Json scrobbles object is missing values."_s, json_obj); return; } QJsonValue value_attr = json_obj["@attr"_L1]; if (!value_attr.isObject()) { - Error(QStringLiteral("Json scrobbles attr is not an object."), value_attr); + Error(u"Json scrobbles attr is not an object."_s, value_attr); return; } QJsonObject obj_attr = value_attr.toObject(); if (obj_attr.isEmpty()) { - Error(QStringLiteral("Json scrobbles attr is empty."), value_attr); + Error(u"Json scrobbles attr is empty."_s, value_attr); return; } QJsonValue value_scrobble = json_obj["scrobble"_L1]; if (!value_scrobble.isObject()) { - Error(QStringLiteral("Json scrobbles scrobble is not an object."), value_scrobble); + Error(u"Json scrobbles scrobble is not an object."_s, value_scrobble); return; } QJsonObject json_obj_scrobble = value_scrobble.toObject(); if (json_obj_scrobble.isEmpty()) { - Error(QStringLiteral("Json scrobbles scrobble is empty."), value_scrobble); + Error(u"Json scrobbles scrobble is empty."_s, value_scrobble); return; } if (!obj_attr.contains("accepted"_L1) || !obj_attr.contains("ignored"_L1)) { - Error(QStringLiteral("Json scrobbles attr is missing values."), obj_attr); + Error(u"Json scrobbles attr is missing values."_s, obj_attr); return; } if (!json_obj_scrobble.contains("artist"_L1) || !json_obj_scrobble.contains("album"_L1) || !json_obj_scrobble.contains("albumArtist"_L1) || !json_obj_scrobble.contains("track"_L1) || !json_obj_scrobble.contains("timestamp"_L1)) { - Error(QStringLiteral("Json scrobbles scrobble is missing values."), json_obj_scrobble); + Error(u"Json scrobbles scrobble is missing values."_s, json_obj_scrobble); return; } @@ -792,7 +792,7 @@ void ScrobblingAPI20::SingleScrobbleRequestFinished(QNetworkReply *reply, Scrobb QJsonValue json_value_song = json_obj_scrobble["track"_L1]; if (!json_value_artist.isObject() || !json_value_album.isObject() || !json_value_song.isObject()) { - Error(QStringLiteral("Json scrobbles scrobble values are not objects."), json_obj_scrobble); + Error(u"Json scrobbles scrobble values are not objects."_s, json_obj_scrobble); return; } @@ -801,12 +801,12 @@ void ScrobblingAPI20::SingleScrobbleRequestFinished(QNetworkReply *reply, Scrobb QJsonObject json_obj_song = json_value_song.toObject(); if (json_obj_artist.isEmpty() || json_obj_album.isEmpty() || json_obj_song.isEmpty()) { - Error(QStringLiteral("Json scrobbles scrobble values objects are empty."), json_obj_scrobble); + Error(u"Json scrobbles scrobble values objects are empty."_s, json_obj_scrobble); return; } if (!json_obj_artist.contains("#text"_L1) || !json_obj_album.contains("#text"_L1) || !json_obj_song.contains("#text"_L1)) { - Error(QStringLiteral("Json scrobbles scrobble values objects are missing #text."), json_obj_artist); + Error(u"Json scrobbles scrobble values objects are missing #text."_s, json_obj_artist); return; } @@ -833,16 +833,16 @@ void ScrobblingAPI20::Love() { qLog(Debug) << name_ << "Sending love for song" << song_playing_.artist() << song_playing_.album() << song_playing_.title(); ParamList params = ParamList() - << Param(QStringLiteral("method"), QStringLiteral("track.love")) - << Param(QStringLiteral("artist"), prefer_albumartist_ ? song_playing_.effective_albumartist() : song_playing_.artist()) - << Param(QStringLiteral("track"), song_playing_.title()); + << Param(u"method"_s, u"track.love"_s) + << Param(u"artist"_s, prefer_albumartist_ ? song_playing_.effective_albumartist() : song_playing_.artist()) + << Param(u"track"_s, song_playing_.title()); if (!song_playing_.album().isEmpty()) { - params << Param(QStringLiteral("album"), song_playing_.album()); + params << Param(u"album"_s, song_playing_.album()); } if (!prefer_albumartist_ && !song_playing_.albumartist().isEmpty()) { - params << Param(QStringLiteral("albumArtist"), song_playing_.albumartist()); + params << Param(u"albumArtist"_s, song_playing_.albumartist()); } QNetworkReply *reply = CreateRequest(params); @@ -867,12 +867,12 @@ void ScrobblingAPI20::LoveRequestFinished(QNetworkReply *reply) { if (json_obj.contains("error"_L1)) { QJsonValue json_value = json_obj["error"_L1]; if (!json_value.isObject()) { - Error(QStringLiteral("Error is not on object.")); + Error(u"Error is not on object."_s); return; } QJsonObject json_obj_error = json_value.toObject(); if (json_obj_error.isEmpty()) { - Error(QStringLiteral("Received empty json error object."), json_obj); + Error(u"Received empty json error object."_s, json_obj); return; } if (json_obj_error.contains("code"_L1) && json_obj_error.contains("#text"_L1)) { @@ -919,64 +919,64 @@ QString ScrobblingAPI20::ErrorString(const ScrobbleErrorCode error) { switch (error) { case ScrobbleErrorCode::NoError: - return QStringLiteral("This error does not exist."); + return u"This error does not exist."_s; case ScrobbleErrorCode::InvalidService: - return QStringLiteral("Invalid service - This service does not exist."); + return u"Invalid service - This service does not exist."_s; case ScrobbleErrorCode::InvalidMethod: - return QStringLiteral("Invalid Method - No method with that name in this package."); + return u"Invalid Method - No method with that name in this package."_s; case ScrobbleErrorCode::AuthenticationFailed: - return QStringLiteral("Authentication Failed - You do not have permissions to access the service."); + return u"Authentication Failed - You do not have permissions to access the service."_s; case ScrobbleErrorCode::InvalidFormat: - return QStringLiteral("Invalid format - This service doesn't exist in that format."); + return u"Invalid format - This service doesn't exist in that format."_s; case ScrobbleErrorCode::InvalidParameters: - return QStringLiteral("Invalid parameters - Your request is missing a required parameter."); + return u"Invalid parameters - Your request is missing a required parameter."_s; case ScrobbleErrorCode::InvalidResourceSpecified: - return QStringLiteral("Invalid resource specified"); + return u"Invalid resource specified"_s; case ScrobbleErrorCode::OperationFailed: - return QStringLiteral("Operation failed - Most likely the backend service failed. Please try again."); + return u"Operation failed - Most likely the backend service failed. Please try again."_s; case ScrobbleErrorCode::InvalidSessionKey: - return QStringLiteral("Invalid session key - Please re-authenticate."); + return u"Invalid session key - Please re-authenticate."_s; case ScrobbleErrorCode::InvalidApiKey: - return QStringLiteral("Invalid API key - You must be granted a valid key by last.fm."); + return u"Invalid API key - You must be granted a valid key by last.fm."_s; case ScrobbleErrorCode::ServiceOffline: - return QStringLiteral("Service Offline - This service is temporarily offline. Try again later."); + return u"Service Offline - This service is temporarily offline. Try again later."_s; case ScrobbleErrorCode::SubscribersOnly: - return QStringLiteral("Subscribers Only - This station is only available to paid last.fm subscribers."); + return u"Subscribers Only - This station is only available to paid last.fm subscribers."_s; case ScrobbleErrorCode::InvalidMethodSignature: - return QStringLiteral("Invalid method signature supplied."); + return u"Invalid method signature supplied."_s; case ScrobbleErrorCode::UnauthorizedToken: - return QStringLiteral("Unauthorized Token - This token has not been authorized."); + return u"Unauthorized Token - This token has not been authorized."_s; case ScrobbleErrorCode::ItemUnavailable: - return QStringLiteral("This item is not available for streaming."); + return u"This item is not available for streaming."_s; case ScrobbleErrorCode::TemporarilyUnavailable: - return QStringLiteral("The service is temporarily unavailable, please try again."); + return u"The service is temporarily unavailable, please try again."_s; case ScrobbleErrorCode::LoginRequired: - return QStringLiteral("Login: User requires to be logged in."); + return u"Login: User requires to be logged in."_s; case ScrobbleErrorCode::TrialExpired: - return QStringLiteral("Trial Expired - This user has no free radio plays left. Subscription required."); + return u"Trial Expired - This user has no free radio plays left. Subscription required."_s; case ScrobbleErrorCode::ErrorDoesNotExist: - return QStringLiteral("This error does not exist."); + return u"This error does not exist."_s; case ScrobbleErrorCode::NotEnoughContent: - return QStringLiteral("Not Enough Content - There is not enough content to play this station."); + return u"Not Enough Content - There is not enough content to play this station."_s; case ScrobbleErrorCode::NotEnoughMembers: - return QStringLiteral("Not Enough Members - This group does not have enough members for radio."); + return u"Not Enough Members - This group does not have enough members for radio."_s; case ScrobbleErrorCode::NotEnoughFans: - return QStringLiteral("Not Enough Fans - This artist does not have enough fans for for radio."); + return u"Not Enough Fans - This artist does not have enough fans for for radio."_s; case ScrobbleErrorCode::NotEnoughNeighbours: - return QStringLiteral("Not Enough Neighbours - There are not enough neighbours for radio."); + return u"Not Enough Neighbours - There are not enough neighbours for radio."_s; case ScrobbleErrorCode::NoPeakRadio: - return QStringLiteral("No Peak Radio - This user is not allowed to listen to radio during peak usage."); + return u"No Peak Radio - This user is not allowed to listen to radio during peak usage."_s; case ScrobbleErrorCode::RadioNotFound: - return QStringLiteral("Radio Not Found - Radio station not found."); + return u"Radio Not Found - Radio station not found."_s; case ScrobbleErrorCode::APIKeySuspended: - return QStringLiteral("Suspended API key - Access for your account has been suspended, please contact Last.fm"); + return u"Suspended API key - Access for your account has been suspended, please contact Last.fm"_s; case ScrobbleErrorCode::Deprecated: - return QStringLiteral("Deprecated - This type of request is no longer supported."); + return u"Deprecated - This type of request is no longer supported."_s; case ScrobbleErrorCode::RateLimitExceeded: - return QStringLiteral("Rate limit exceeded - Your IP has made too many requests in a short period."); + return u"Rate limit exceeded - Your IP has made too many requests in a short period."_s; } - return QStringLiteral("Unknown error."); + return u"Unknown error."_s; } diff --git a/src/utilities/timeutils.cpp b/src/utilities/timeutils.cpp index 817409c47..fd416d5f2 100644 --- a/src/utilities/timeutils.cpp +++ b/src/utilities/timeutils.cpp @@ -32,6 +32,8 @@ namespace Utilities { +using namespace Qt::Literals::StringLiterals; + QString PrettyTime(int seconds) { // last.fm sometimes gets the track length wrong, so you end up with negative times. @@ -82,8 +84,8 @@ QString Ago(const qint64 seconds_since_epoch, const QLocale &locale) { const qint64 days_ago = then.date().daysTo(now.date()); const QString time = then.time().toString(locale.timeFormat(QLocale::ShortFormat)); - if (days_ago == 0) return QObject::tr("Today") + QLatin1Char(' ') + time; - if (days_ago == 1) return QObject::tr("Yesterday") + QLatin1Char(' ') + time; + if (days_ago == 0) return QObject::tr("Today") + u' ' + time; + if (days_ago == 1) return QObject::tr("Yesterday") + u' ' + time; if (days_ago <= 7) return QObject::tr("%1 days ago").arg(days_ago); return then.date().toString(locale.dateFormat(QLocale::ShortFormat)); @@ -107,7 +109,7 @@ QString PrettyFutureDate(const QDate date) { QDateTime ParseRFC822DateTime(const QString &text) { - static const QRegularExpression regexp(QStringLiteral("(\\d{1,2}) (\\w{3,12}) (\\d+) (\\d{1,2}):(\\d{1,2}):(\\d{1,2})")); + static const QRegularExpression regexp(u"(\\d{1,2}) (\\w{3,12}) (\\d+) (\\d{1,2}):(\\d{1,2}):(\\d{1,2})"_s); QRegularExpressionMatch re_match = regexp.match(text); if (!re_match.hasMatch()) { return QDateTime(); @@ -116,30 +118,30 @@ QDateTime ParseRFC822DateTime(const QString &text) { enum class MatchNames { DAYS = 1, MONTHS, YEARS, HOURS, MINUTES, SECONDS }; QMap monthmap; - monthmap[QStringLiteral("Jan")] = 1; - monthmap[QStringLiteral("Feb")] = 2; - monthmap[QStringLiteral("Mar")] = 3; - monthmap[QStringLiteral("Apr")] = 4; - monthmap[QStringLiteral("May")] = 5; - monthmap[QStringLiteral("Jun")] = 6; - monthmap[QStringLiteral("Jul")] = 7; - monthmap[QStringLiteral("Aug")] = 8; - monthmap[QStringLiteral("Sep")] = 9; - monthmap[QStringLiteral("Oct")] = 10; - monthmap[QStringLiteral("Nov")] = 11; - monthmap[QStringLiteral("Dec")] = 12; - monthmap[QStringLiteral("January")] = 1; - monthmap[QStringLiteral("February")] = 2; - monthmap[QStringLiteral("March")] = 3; - monthmap[QStringLiteral("April")] = 4; - monthmap[QStringLiteral("May")] = 5; - monthmap[QStringLiteral("June")] = 6; - monthmap[QStringLiteral("July")] = 7; - monthmap[QStringLiteral("August")] = 8; - monthmap[QStringLiteral("September")] = 9; - monthmap[QStringLiteral("October")] = 10; - monthmap[QStringLiteral("November")] = 11; - monthmap[QStringLiteral("December")] = 12; + monthmap[u"Jan"_s] = 1; + monthmap[u"Feb"_s] = 2; + monthmap[u"Mar"_s] = 3; + monthmap[u"Apr"_s] = 4; + monthmap[u"May"_s] = 5; + monthmap[u"Jun"_s] = 6; + monthmap[u"Jul"_s] = 7; + monthmap[u"Aug"_s] = 8; + monthmap[u"Sep"_s] = 9; + monthmap[u"Oct"_s] = 10; + monthmap[u"Nov"_s] = 11; + monthmap[u"Dec"_s] = 12; + monthmap[u"January"_s] = 1; + monthmap[u"February"_s] = 2; + monthmap[u"March"_s] = 3; + monthmap[u"April"_s] = 4; + monthmap[u"May"_s] = 5; + monthmap[u"June"_s] = 6; + monthmap[u"July"_s] = 7; + monthmap[u"August"_s] = 8; + monthmap[u"September"_s] = 9; + monthmap[u"October"_s] = 10; + monthmap[u"November"_s] = 11; + monthmap[u"December"_s] = 12; const QDate date(re_match.captured(static_cast(MatchNames::YEARS)).toInt(), monthmap[re_match.captured(static_cast(MatchNames::MONTHS))], re_match.captured(static_cast(MatchNames::DAYS)).toInt());