mirror of
https://github.com/RetroDECK/ES-DE.git
synced 2024-12-02 02:55:38 +00:00
237 lines
9.8 KiB
C++
237 lines
9.8 KiB
C++
// SPDX-License-Identifier: MIT
|
|
//
|
|
// EmulationStation Desktop Edition
|
|
// FileSorts.cpp
|
|
//
|
|
// Gamelist sorting functions.
|
|
// Actual sorting takes place in FileData.
|
|
//
|
|
|
|
#include "FileSorts.h"
|
|
|
|
#include "utils/StringUtil.h"
|
|
|
|
#include <algorithm>
|
|
#include <string>
|
|
|
|
namespace FileSorts
|
|
{
|
|
const FileData::SortType typesArr[] = {
|
|
FileData::SortType(&compareName, "filename, ascending"),
|
|
FileData::SortType(&compareNameDescending, "filename, descending"),
|
|
|
|
FileData::SortType(&compareRating, "rating, ascending"),
|
|
FileData::SortType(&compareRatingDescending, "rating, descending"),
|
|
|
|
FileData::SortType(&compareReleaseDate, "release date, ascending"),
|
|
FileData::SortType(&compareReleaseDateDescending, "release date, descending"),
|
|
|
|
FileData::SortType(&compareDeveloper, "developer, ascending"),
|
|
FileData::SortType(&compareDeveloperDescending, "developer, descending"),
|
|
|
|
FileData::SortType(&comparePublisher, "publisher, ascending"),
|
|
FileData::SortType(&comparePublisherDescending, "publisher, descending"),
|
|
|
|
FileData::SortType(&compareGenre, "genre, ascending"),
|
|
FileData::SortType(&compareGenreDescending, "genre, descending"),
|
|
|
|
FileData::SortType(&compareNumPlayers, "players, ascending"),
|
|
FileData::SortType(&compareNumPlayersDescending, "players, descending"),
|
|
|
|
FileData::SortType(&compareLastPlayed, "last played, ascending"),
|
|
FileData::SortType(&compareLastPlayedDescending, "last played, descending"),
|
|
|
|
FileData::SortType(&compareTimesPlayed, "times played, ascending"),
|
|
FileData::SortType(&compareTimesPlayedDescending, "times played, descending"),
|
|
|
|
FileData::SortType(&compareSystem, "system, ascending"),
|
|
FileData::SortType(&compareSystemDescending, "system, descending")};
|
|
|
|
const std::vector<FileData::SortType> SortTypes(typesArr,
|
|
typesArr +
|
|
sizeof(typesArr) / sizeof(typesArr[0]));
|
|
|
|
bool compareName(const FileData* file1, const FileData* file2)
|
|
{
|
|
// We compare the actual metadata name, as collection files have the system
|
|
// appended which messes up the order.
|
|
std::string name1 = Utils::String::toUpper(file1->metadata.get("sortname"));
|
|
std::string name2 = Utils::String::toUpper(file2->metadata.get("sortname"));
|
|
if (name1.empty())
|
|
name1 = Utils::String::toUpper(file1->metadata.get("name"));
|
|
if (name2.empty())
|
|
name2 = Utils::String::toUpper(file2->metadata.get("name"));
|
|
return name1.compare(name2) < 0;
|
|
}
|
|
|
|
bool compareNameDescending(const FileData* file1, const FileData* file2)
|
|
{
|
|
std::string name1 = Utils::String::toUpper(file1->metadata.get("sortname"));
|
|
std::string name2 = Utils::String::toUpper(file2->metadata.get("sortname"));
|
|
if (name1.empty())
|
|
name1 = Utils::String::toUpper(file1->metadata.get("name"));
|
|
if (name2.empty())
|
|
name2 = Utils::String::toUpper(file2->metadata.get("name"));
|
|
return name1.compare(name2) > 0;
|
|
}
|
|
|
|
bool compareRating(const FileData* file1, const FileData* file2)
|
|
{
|
|
return file1->metadata.getFloat("rating") < file2->metadata.getFloat("rating");
|
|
}
|
|
|
|
bool compareRatingDescending(const FileData* file1, const FileData* file2)
|
|
{
|
|
return file1->metadata.getFloat("rating") > file2->metadata.getFloat("rating");
|
|
}
|
|
|
|
bool compareReleaseDate(const FileData* file1, const FileData* file2)
|
|
{
|
|
// Since it's stored as an ISO string (YYYYMMDDTHHMMSS), we can compare as a string
|
|
// which is a lot faster than the time casts and the time comparisons.
|
|
return (file1)->metadata.get("releasedate") < (file2)->metadata.get("releasedate");
|
|
}
|
|
|
|
bool compareReleaseDateDescending(const FileData* file1, const FileData* file2)
|
|
{
|
|
return (file1)->metadata.get("releasedate") > (file2)->metadata.get("releasedate");
|
|
}
|
|
|
|
bool compareDeveloper(const FileData* file1, const FileData* file2)
|
|
{
|
|
std::string developer1 = Utils::String::toUpper(file1->metadata.get("developer"));
|
|
std::string developer2 = Utils::String::toUpper(file2->metadata.get("developer"));
|
|
return developer1.compare(developer2) < 0;
|
|
}
|
|
|
|
bool compareDeveloperDescending(const FileData* file1, const FileData* file2)
|
|
{
|
|
std::string developer1 = Utils::String::toUpper(file1->metadata.get("developer"));
|
|
std::string developer2 = Utils::String::toUpper(file2->metadata.get("developer"));
|
|
return developer1.compare(developer2) > 0;
|
|
}
|
|
|
|
bool comparePublisher(const FileData* file1, const FileData* file2)
|
|
{
|
|
std::string publisher1 = Utils::String::toUpper(file1->metadata.get("publisher"));
|
|
std::string publisher2 = Utils::String::toUpper(file2->metadata.get("publisher"));
|
|
return publisher1.compare(publisher2) < 0;
|
|
}
|
|
|
|
bool comparePublisherDescending(const FileData* file1, const FileData* file2)
|
|
{
|
|
std::string publisher1 = Utils::String::toUpper(file1->metadata.get("publisher"));
|
|
std::string publisher2 = Utils::String::toUpper(file2->metadata.get("publisher"));
|
|
return publisher1.compare(publisher2) > 0;
|
|
}
|
|
|
|
bool compareGenre(const FileData* file1, const FileData* file2)
|
|
{
|
|
std::string genre1 = Utils::String::toUpper(file1->metadata.get("genre"));
|
|
std::string genre2 = Utils::String::toUpper(file2->metadata.get("genre"));
|
|
return genre1.compare(genre2) < 0;
|
|
}
|
|
|
|
bool compareGenreDescending(const FileData* file1, const FileData* file2)
|
|
{
|
|
std::string genre1 = Utils::String::toUpper(file1->metadata.get("genre"));
|
|
std::string genre2 = Utils::String::toUpper(file2->metadata.get("genre"));
|
|
return genre1.compare(genre2) > 0;
|
|
}
|
|
|
|
bool compareNumPlayers(const FileData* file1, const FileData* file2)
|
|
{
|
|
std::string file1Players = (file1)->metadata.get("players");
|
|
std::string file2Players = (file2)->metadata.get("players");
|
|
unsigned int file1Int = 0;
|
|
unsigned int file2Int = 0;
|
|
size_t dashPos;
|
|
// If there is a range of players such as '1-4' then capture the number after the dash.
|
|
dashPos = file1Players.find("-");
|
|
if (dashPos != std::string::npos)
|
|
file1Players = file1Players.substr(dashPos + 1, file1Players.size() - dashPos - 1);
|
|
dashPos = file2Players.find("-");
|
|
if (dashPos != std::string::npos)
|
|
file2Players = file2Players.substr(dashPos + 1, file2Players.size() - dashPos - 1);
|
|
// Any non-numeric value will end up as zero.
|
|
if (!file1Players.empty() &&
|
|
std::all_of(file1Players.begin(), file1Players.end(), ::isdigit)) {
|
|
file1Int = stoi(file1Players);
|
|
}
|
|
if (!file2Players.empty() &&
|
|
std::all_of(file2Players.begin(), file2Players.end(), ::isdigit)) {
|
|
file2Int = stoi(file2Players);
|
|
}
|
|
return file1Int < file2Int;
|
|
}
|
|
|
|
bool compareNumPlayersDescending(const FileData* file1, const FileData* file2)
|
|
{
|
|
std::string file1Players = (file1)->metadata.get("players");
|
|
std::string file2Players = (file2)->metadata.get("players");
|
|
unsigned int file1Int = 0;
|
|
unsigned int file2Int = 0;
|
|
size_t dashPos;
|
|
dashPos = file1Players.find("-");
|
|
if (dashPos != std::string::npos)
|
|
file1Players = file1Players.substr(dashPos + 1, file1Players.size() - dashPos - 1);
|
|
dashPos = file2Players.find("-");
|
|
if (dashPos != std::string::npos)
|
|
file2Players = file2Players.substr(dashPos + 1, file2Players.size() - dashPos - 1);
|
|
if (!file1Players.empty() &&
|
|
std::all_of(file1Players.begin(), file1Players.end(), ::isdigit)) {
|
|
file1Int = stoi(file1Players);
|
|
}
|
|
if (!file2Players.empty() &&
|
|
std::all_of(file2Players.begin(), file2Players.end(), ::isdigit)) {
|
|
file2Int = stoi(file2Players);
|
|
}
|
|
return file1Int > file2Int;
|
|
}
|
|
|
|
bool compareLastPlayed(const FileData* file1, const FileData* file2)
|
|
{
|
|
// Since it's stored as an ISO string (YYYYMMDDTHHMMSS), we can compare as a string
|
|
// which is a lot faster than the time casts and the time comparisons.
|
|
return (file1)->metadata.get("lastplayed") > (file2)->metadata.get("lastplayed");
|
|
}
|
|
|
|
bool compareLastPlayedDescending(const FileData* file1, const FileData* file2)
|
|
{
|
|
return (file1)->metadata.get("lastplayed") < (file2)->metadata.get("lastplayed");
|
|
}
|
|
|
|
bool compareTimesPlayed(const FileData* file1, const FileData* file2)
|
|
{
|
|
// Only games have playcount metadata.
|
|
if (file1->metadata.getType() == GAME_METADATA &&
|
|
file2->metadata.getType() == GAME_METADATA) {
|
|
return (file1)->metadata.getInt("playcount") < (file2)->metadata.getInt("playcount");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool compareTimesPlayedDescending(const FileData* file1, const FileData* file2)
|
|
{
|
|
if (file1->metadata.getType() == GAME_METADATA &&
|
|
file2->metadata.getType() == GAME_METADATA) {
|
|
return (file1)->metadata.getInt("playcount") > (file2)->metadata.getInt("playcount");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool compareSystem(const FileData* file1, const FileData* file2)
|
|
{
|
|
std::string system1 = Utils::String::toUpper(file1->getSystemName());
|
|
std::string system2 = Utils::String::toUpper(file2->getSystemName());
|
|
return system1.compare(system2) < 0;
|
|
}
|
|
|
|
bool compareSystemDescending(const FileData *file1, const FileData *file2) {
|
|
std::string system1 = Utils::String::toUpper(file1->getSystemName());
|
|
std::string system2 = Utils::String::toUpper(file2->getSystemName());
|
|
return system1.compare(system2) > 0;
|
|
}
|
|
|
|
} // namespace FileSorts
|