owen/lms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Auto reformatted the base, ref #470

Browse Source
This commit is contained in:
emeric
2024-05-24 23:31:52 +02:00
parent 83b868673c
commit 39941d90a3
460 changed files with 8583 additions and 8514 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/services/recommendation/impl/playlist-constraints/ConsecutiveArtists.cpp
+47 -51
View File
@@ -21,77 +21,73 @@
#include <algorithm>
#include "core/ILogger.hpp"
#include "database/Db.hpp"
#include "database/Release.hpp"
#include "database/Session.hpp"
#include "database/Track.hpp"
#include "core/ILogger.hpp"
namespace lms::recommendation::PlaylistGeneratorConstraint
{
namespace
{
std::size_t
countCommonArtists(const ArtistContainer& artists1, const ArtistContainer& artists2)
{
ArtistContainer intersection;
namespace
{
std::size_t countCommonArtists(const ArtistContainer& artists1, const ArtistContainer& artists2)
{
ArtistContainer intersection;
std::set_intersection(std::cbegin(artists1), std::cend(artists1),
std::cbegin(artists2), std::cend(artists2),
std::back_inserter(intersection));
std::set_intersection(std::cbegin(artists1), std::cend(artists1),
std::cbegin(artists2), std::cend(artists2),
std::back_inserter(intersection));
return intersection.size();
}
}
return intersection.size();
}
} // namespace
ConsecutiveArtists::ConsecutiveArtists(db::Db& db)
: _db {db}
{}
ConsecutiveArtists::ConsecutiveArtists(db::Db& db)
: _db{ db }
{
}
float
ConsecutiveArtists::computeScore(const std::vector<db::TrackId>& trackIds, std::size_t trackIndex)
{
assert(!trackIds.empty());
assert(trackIndex <= trackIds.size() - 1);
float ConsecutiveArtists::computeScore(const std::vector<db::TrackId>& trackIds, std::size_t trackIndex)
{
assert(!trackIds.empty());
assert(trackIndex <= trackIds.size() - 1);
const ArtistContainer artists {getArtists(trackIds[trackIndex])};
const ArtistContainer artists{ getArtists(trackIds[trackIndex]) };
constexpr std::size_t rangeSize{ 3 }; // check up to rangeSize tracks before/after the target track
static_assert(rangeSize > 0);
constexpr std::size_t rangeSize{ 3 }; // check up to rangeSize tracks before/after the target track
static_assert(rangeSize > 0);
float score {};
for (std::size_t i {1}; i < rangeSize; ++i)
{
if (trackIndex >= i)
score += countCommonArtists(artists, getArtists(trackIds[trackIndex - i])) / static_cast<float>(i);
float score{};
for (std::size_t i{ 1 }; i < rangeSize; ++i)
{
if (trackIndex >= i)
score += countCommonArtists(artists, getArtists(trackIds[trackIndex - i])) / static_cast<float>(i);
if (trackIndex + i < trackIds.size())
score += countCommonArtists(artists, getArtists(trackIds[trackIndex + i])) / static_cast<float>(i);
}
if (trackIndex + i < trackIds.size())
score += countCommonArtists(artists, getArtists(trackIds[trackIndex + i])) / static_cast<float>(i);
}
return score;
}
return score;
}
ArtistContainer
ConsecutiveArtists::getArtists(db::TrackId trackId)
{
using namespace db;
ArtistContainer ConsecutiveArtists::getArtists(db::TrackId trackId)
{
using namespace db;
ArtistContainer res;
ArtistContainer res;
Session& dbSession {_db.getTLSSession()};
auto transaction {dbSession.createReadTransaction()};
Session& dbSession{ _db.getTLSSession() };
auto transaction{ dbSession.createReadTransaction() };
const Track::pointer track {Track::find(dbSession, trackId)};
if (!track)
return res;
const Track::pointer track{ Track::find(dbSession, trackId) };
if (!track)
return res;
res = track->getArtistIds({});
std::sort(std::begin(res), std::end(res));
res = track->getArtistIds({});
std::sort(std::begin(res), std::end(res));
return res;
}
} // namespace lms::recommendation
return res;
}
} // namespace lms::recommendation::PlaylistGeneratorConstraint
src/libs/services/recommendation/impl/playlist-constraints/ConsecutiveArtists.hpp
+10 -11
View File
@@ -25,21 +25,20 @@
namespace lms::db
{
class Db;
class Db;
}
namespace lms::recommendation::PlaylistGeneratorConstraint
{
class ConsecutiveArtists : public IConstraint
{
public:
ConsecutiveArtists(db::Db& db);
class ConsecutiveArtists : public IConstraint
{
public:
ConsecutiveArtists(db::Db& db);
private:
float computeScore(const TrackContainer& trackIds, std::size_t trackIndex) override;
ArtistContainer getArtists(db::TrackId trackId);
private:
float computeScore(const TrackContainer& trackIds, std::size_t trackIndex) override;
ArtistContainer getArtists(db::TrackId trackId);
db::Db& _db;
};
db::Db& _db;
};
} // namespace lms::recommendation::PlaylistGeneratorConstraint
src/libs/services/recommendation/impl/playlist-constraints/ConsecutiveReleases.cpp
+36 -38
View File
@@ -19,59 +19,57 @@
#include "ConsecutiveReleases.hpp"
#include "core/ILogger.hpp"
#include "database/Db.hpp"
#include "database/Release.hpp"
#include "database/Session.hpp"
#include "database/Track.hpp"
#include "core/ILogger.hpp"
namespace lms::recommendation::PlaylistGeneratorConstraint
{
ConsecutiveReleases::ConsecutiveReleases(db::Db& db)
: _db {db}
{}
ConsecutiveReleases::ConsecutiveReleases(db::Db& db)
: _db{ db }
{
}
float
ConsecutiveReleases::computeScore(const std::vector<db::TrackId>& trackIds, std::size_t trackIndex)
{
assert(!trackIds.empty());
assert(trackIndex <= trackIds.size() - 1);
float ConsecutiveReleases::computeScore(const std::vector<db::TrackId>& trackIds, std::size_t trackIndex)
{
assert(!trackIds.empty());
assert(trackIndex <= trackIds.size() - 1);
const db::ReleaseId releaseId {getReleaseId(trackIds[trackIndex])};
const db::ReleaseId releaseId{ getReleaseId(trackIds[trackIndex]) };
constexpr std::size_t rangeSize{ 3 }; // check up to rangeSize tracks before/after the target track
static_assert(rangeSize > 0);
constexpr std::size_t rangeSize{ 3 }; // check up to rangeSize tracks before/after the target track
static_assert(rangeSize > 0);
float score {};
for (std::size_t i {1}; i < rangeSize; ++i)
{
if ((trackIndex >= i) && getReleaseId(trackIds[trackIndex - i]) == releaseId)
score += (1.f / static_cast<float>(i));
float score{};
for (std::size_t i{ 1 }; i < rangeSize; ++i)
{
if ((trackIndex >= i) && getReleaseId(trackIds[trackIndex - i]) == releaseId)
score += (1.f / static_cast<float>(i));
if ((trackIndex + i < trackIds.size()) && getReleaseId(trackIds[trackIndex + i]) == releaseId)
score += (1.f / static_cast<float>(i));
}
if ((trackIndex + i < trackIds.size()) && getReleaseId(trackIds[trackIndex + i]) == releaseId)
score += (1.f / static_cast<float>(i));
}
return score;
}
return score;
}
db::ReleaseId
ConsecutiveReleases::getReleaseId(db::TrackId trackId)
{
using namespace db;
db::ReleaseId ConsecutiveReleases::getReleaseId(db::TrackId trackId)
{
using namespace db;
Session& dbSession {_db.getTLSSession()};
auto transaction {dbSession.createReadTransaction()};
Session& dbSession{ _db.getTLSSession() };
auto transaction{ dbSession.createReadTransaction() };
const Track::pointer track {Track::find(dbSession, trackId)};
if (!track)
return {};
const Track::pointer track{ Track::find(dbSession, trackId) };
if (!track)
return {};
const Release::pointer release {track->getRelease()};
if (!release)
return {};
return release->getId();
}
} // namespace lms::recommendation
const Release::pointer release{ track->getRelease() };
if (!release)
return {};
return release->getId();
}
} // namespace lms::recommendation::PlaylistGeneratorConstraint
src/libs/services/recommendation/impl/playlist-constraints/ConsecutiveReleases.hpp
+11 -12
View File
@@ -25,22 +25,21 @@
namespace lms::db
{
class Db;
class Db;
}
namespace lms::recommendation::PlaylistGeneratorConstraint
{
class ConsecutiveReleases : public IConstraint
{
public:
ConsecutiveReleases(db::Db& db);
class ConsecutiveReleases : public IConstraint
{
public:
ConsecutiveReleases(db::Db& db);
private:
float computeScore(const std::vector<db::TrackId>& trackIds, std::size_t trackIndex) override;
private:
float computeScore(const std::vector<db::TrackId>& trackIds, std::size_t trackIndex) override;
db::ReleaseId getReleaseId(db::TrackId trackId);
db::Db& _db;
};
} // namespace lms::recommendation
db::ReleaseId getReleaseId(db::TrackId trackId);
db::Db& _db;
};
} // namespace lms::recommendation::PlaylistGeneratorConstraint
src/libs/services/recommendation/impl/playlist-constraints/DuplicateTracks.cpp
+6 -8
View File
@@ -23,11 +23,9 @@
namespace lms::recommendation::PlaylistGeneratorConstraint
{
float
DuplicateTracks::computeScore(const std::vector<db::TrackId>& trackIds, std::size_t trackIndex)
{
const auto count {std::count(std::cbegin(trackIds), std::cend(trackIds), trackIds[trackIndex])};
return count == 1 ? 0 : 1000;
}
} // namespace lms::recommendation
float DuplicateTracks::computeScore(const std::vector<db::TrackId>& trackIds, std::size_t trackIndex)
{
const auto count{ std::count(std::cbegin(trackIds), std::cend(trackIds), trackIds[trackIndex]) };
return count == 1 ? 0 : 1000;
}
} // namespace lms::recommendation::PlaylistGeneratorConstraint
src/libs/services/recommendation/impl/playlist-constraints/DuplicateTracks.hpp
+6 -7
View File
@@ -23,10 +23,9 @@
namespace lms::recommendation::PlaylistGeneratorConstraint
{
class DuplicateTracks : public IConstraint
{
private:
float computeScore(const std::vector<db::TrackId>& trackIds, std::size_t trackIndex) override;
};
} // namespace lms::recommendation::PlaylistGeneratorConstraints
class DuplicateTracks : public IConstraint
{
private:
float computeScore(const std::vector<db::TrackId>& trackIds, std::size_t trackIndex) override;
};
} // namespace lms::recommendation::PlaylistGeneratorConstraint
src/libs/services/recommendation/impl/playlist-constraints/IConstraint.hpp
+11 -11
View File
@@ -25,15 +25,15 @@
namespace lms::recommendation::PlaylistGeneratorConstraint
{
class IConstraint
{
public:
virtual ~IConstraint() = default;
class IConstraint
{
public:
virtual ~IConstraint() = default;
// compute the score of the track at index trackIndex
// 0: best
// 1: worst
// > 1 : violation
virtual float computeScore(const TrackContainer& trackIds, std::size_t trackIndex) = 0;
};
} // namespace lms::recommendation
// compute the score of the track at index trackIndex
// 0: best
// 1: worst
// > 1 : violation
virtual float computeScore(const TrackContainer& trackIds, std::size_t trackIndex) = 0;
};
} // namespace lms::recommendation::PlaylistGeneratorConstraint