improve: account enums direcly instead of raw types

src/account/account.cpp

@@ -10,6 +10,7 @@
 #include "account/account.hpp"
 
 #include "account/account_repository_db.hpp"
+#include "account/account_info.hpp"
 #include "security/argon.hpp"
 #include "utils/tools.hpp"
 #include "enums/account_coins.hpp"
@@ -34,113 +35,116 @@ Account::Account(std::string descriptor) :
 	m_account->accountType = ACCOUNT_TYPE_NORMAL;
 }
 
-uint8_t Account::load() {
+AccountErrors_t Account::load() {
+	using enum AccountErrors_t;
 	if (m_account->id != 0 && g_accountRepository().loadByID(m_account->id, m_account)) {
 		m_accLoaded = true;
-		return enumToValue(AccountErrors_t::Ok);
+		return Ok;
 	}
 
 	if (!m_descriptor.empty() && g_accountRepository().loadByEmailOrName(getProtocolCompat(), m_descriptor, m_account)) {
 		m_accLoaded = true;
-		return enumToValue(AccountErrors_t::Ok);
+		return Ok;
 	}
 
 	if (!m_descriptor.empty() && g_accountRepository().loadBySession(m_descriptor, m_account)) {
 		m_accLoaded = true;
-		return enumToValue(AccountErrors_t::Ok);
+		return Ok;
 	}
 
 	updatePremiumTime();
-	return enumToValue(AccountErrors_t::LoadingAccount);
+	return LoadingAccount;
 }
 
-uint8_t Account::reload() {
+AccountErrors_t Account::reload() {
 	if (!m_accLoaded) {
-		return enumToValue(AccountErrors_t::NotInitialized);
+		return AccountErrors_t::NotInitialized;
 	}
 
 	return load();
 }
 
-uint8_t Account::save() {
+AccountErrors_t Account::save() const {
+	using enum AccountErrors_t;
 	if (!m_accLoaded) {
-		return enumToValue(AccountErrors_t::NotInitialized);
+		return NotInitialized;
 	}
-
 	if (!g_accountRepository().save(m_account)) {
-		return enumToValue(AccountErrors_t::Storage);
+		return Storage;
 	}
-
-	return enumToValue(AccountErrors_t::Ok);
+	return Ok;
 }
 
-std::tuple<uint32_t, uint8_t> Account::getCoins(const uint8_t &type) const {
+std::tuple<uint32_t, AccountErrors_t> Account::getCoins(CoinType type) const {
+	using enum AccountErrors_t;
 	if (!m_accLoaded) {
-		return { 0, enumToValue(AccountErrors_t::NotInitialized) };
+		return { 0, NotInitialized };
 	}
 
 	uint32_t coins = 0;
 	if (!g_accountRepository().getCoins(m_account->id, type, coins)) {
-		return { 0, enumToValue(AccountErrors_t::Storage) };
+		return { 0, Storage };
 	}
 
-	return { coins, enumToValue(AccountErrors_t::Ok) };
+	return { coins, Ok };
 }
 
-uint8_t Account::addCoins(const uint8_t &type, const uint32_t &amount, const std::string &detail) {
+AccountErrors_t Account::addCoins(CoinType type, const uint32_t &amount, const std::string &detail) {
+	using enum AccountErrors_t;
 	if (!m_accLoaded) {
-		return enumToValue(AccountErrors_t::NotInitialized);
+		return NotInitialized;
 	}
 
 	if (amount == 0) {
-		return enumToValue(AccountErrors_t::Ok);
+		return Ok;
 	}
 
 	auto [coins, result] = getCoins(type);
 
-	if (AccountErrors_t::Ok != enumFromValue<AccountErrors_t>(result)) {
+	if (Ok != result) {
 		return result;
 	}
 
 	if (!g_accountRepository().setCoins(m_account->id, type, coins + amount)) {
-		return enumToValue(AccountErrors_t::Storage);
+		return Storage;
 	}
 
-	registerCoinTransaction(enumToValue(CoinTransactionType::Add), type, amount, detail);
+	registerCoinTransaction(CoinTransactionType::Add, type, amount, detail);
 
-	return enumToValue(AccountErrors_t::Ok);
+	return Ok;
 }
 
-uint8_t Account::removeCoins(const uint8_t &type, const uint32_t &amount, const std::string &detail) {
+AccountErrors_t Account::removeCoins(CoinType type, const uint32_t &amount, const std::string &detail) {
+	using enum AccountErrors_t;
 	if (!m_accLoaded) {
-		return enumToValue(AccountErrors_t::NotInitialized);
+		return NotInitialized;
 	}
 
 	if (amount == 0) {
-		return enumToValue(AccountErrors_t::Ok);
+		return Ok;
 	}
 
 	auto [coins, result] = getCoins(type);
 
-	if (AccountErrors_t::Ok != enumFromValue<AccountErrors_t>(result)) {
+	if (Ok != result) {
 		return result;
 	}
 
 	if (coins < amount) {
 		g_logger().info("Account doesn't have enough coins! current[{}], remove:[{}]", coins, amount);
-		return enumToValue(AccountErrors_t::RemoveCoins);
+		return RemoveCoins;
 	}
 
 	if (!g_accountRepository().setCoins(m_account->id, type, coins - amount)) {
-		return enumToValue(AccountErrors_t::Storage);
+		return Storage;
 	}
 
-	registerCoinTransaction(enumToValue(CoinTransactionType::Remove), type, amount, detail);
+	registerCoinTransaction(CoinTransactionType::Remove, type, amount, detail);
 
-	return enumToValue(AccountErrors_t::Ok);
+	return Ok;
 }
 
-void Account::registerCoinTransaction(const uint8_t &transactionType, const uint8_t &type, const uint32_t &amount, const std::string &detail) {
+void Account::registerCoinTransaction(CoinTransactionType transactionType, CoinType type, const uint32_t &amount, const std::string &detail) {
 	if (!m_accLoaded) {
 		return;
 	}
@@ -208,12 +212,12 @@ void Account::setPremiumDays(const int32_t &days) {
 	return m_account->premiumDaysPurchased;
 }
 
-uint8_t Account::setAccountType(const uint8_t &accountType) {
+AccountErrors_t Account::setAccountType(AccountType accountType) {
 	m_account->accountType = accountType;
-	return enumToValue(AccountErrors_t::Ok);
+	return AccountErrors_t::Ok;
 }
 
-[[nodiscard]] uint8_t Account::getAccountType() const {
+[[nodiscard]] AccountType Account::getAccountType() const {
 	return m_account->accountType;
 }
 
@@ -240,14 +244,15 @@ void Account::updatePremiumTime() {
 		return;
 	}
 
-	if (AccountErrors_t::Ok != enumFromValue<AccountErrors_t>(save())) {
+	if (AccountErrors_t::Ok != save()) {
 		g_logger().error("Failed to update account premium time: [{}]", getDescriptor());
 	}
 }
 
-std::tuple<phmap::flat_hash_map<std::string, uint64_t>, uint8_t>
+std::tuple<phmap::flat_hash_map<std::string, uint64_t>, AccountErrors_t>
 Account::getAccountPlayers() const {
-	auto valueToReturn = enumToValue(m_accLoaded ? AccountErrors_t::Ok : AccountErrors_t::NotInitialized);
+	using enum AccountErrors_t;
+	auto valueToReturn = m_accLoaded ? Ok : NotInitialized;
 	return { m_account->players, valueToReturn };
 }
 

src/account/account.hpp

@@ -11,6 +11,11 @@
 
 struct AccountInfo;
 
+enum class CoinType : uint8_t;
+enum class CoinTransactionType : uint8_t;
+enum class AccountErrors_t : uint8_t;
+enum AccountType : uint8_t;
+
 class Account {
 public:
 	explicit Account(const uint32_t &id);
@@ -26,7 +31,7 @@ class Account {
 	 * @return uint32_t Number of coins
 	 * @return AccountErrors_t AccountErrors_t::Ok(0) Success, otherwise Fail.
 	 */
-	[[nodiscard]] std::tuple<uint32_t, uint8_t> getCoins(const uint8_t &type) const;
+	[[nodiscard]] std::tuple<uint32_t, AccountErrors_t> getCoins(CoinType type) const;
 
 	/**
 	 * @brief Add coins to the account.
@@ -35,7 +40,7 @@ class Account {
 	 * @param amount Amount of coins to be added
 	 * @return AccountErrors_t AccountErrors_t::Ok(0) Success, otherwise Fail.
 	 */
-	uint8_t addCoins(const uint8_t &type, const uint32_t &amount, const std::string &detail = "ADD Coins");
+	AccountErrors_t addCoins(CoinType type, const uint32_t &amount, const std::string &detail = "ADD Coins");
 
 	/**
 	 * @brief Removes coins from the account.
@@ -44,7 +49,7 @@ class Account {
 	 * @param amount Amount of coins to be removed
 	 * @return AccountErrors_t AccountErrors_t::Ok(0) Success, otherwise Fail.
 	 */
-	uint8_t removeCoins(const uint8_t &type, const uint32_t &amount, const std::string &detail = "REMOVE Coins");
+	AccountErrors_t removeCoins(CoinType type, const uint32_t &amount, const std::string &detail = "REMOVE Coins");
 
 	/**
 	 * @brief Registers a coin transaction.
@@ -53,7 +58,7 @@ class Account {
 	 * @param amount Amount of coins to be added
 	 * @param detail Detail of the transaction
 	 */
-	void registerCoinTransaction(const uint8_t &transactionType, const uint8_t &type, const uint32_t &amount, const std::string &detail);
+	void registerCoinTransaction(CoinTransactionType transactionType, CoinType type, const uint32_t &amount, const std::string &detail);
 
 	/***************************************************************************
 	 * Account Load/Save
@@ -64,22 +69,22 @@ class Account {
 	 *
 	 * @return AccountErrors_t AccountErrors_t::Ok(0) Success, otherwise Fail.
 	 */
-	uint8_t save();
+	AccountErrors_t save() const;
 
 	/**
 	 * @brief Load Account Information.
 	 *
 	 * @return AccountErrors_t AccountErrors_t::Ok(0) Success, otherwise Fail.
 	 */
-	uint8_t load();
+	AccountErrors_t load();
 
 	/**
 	 * @brief Re-Load Account Information to get update information(mainly the
 	 * players list).
 	 *
 	 * @return AccountErrors_t AccountErrors_t::Ok(0) Success, otherwise Fail.
 	 */
-	uint8_t reload();
+	AccountErrors_t reload();
 
 	/***************************************************************************
 	 * Setters and Getters
@@ -107,12 +112,12 @@ class Account {
 
 	[[nodiscard]] time_t getPremiumLastDay() const;
 
-	uint8_t setAccountType(const uint8_t &accountType);
-	[[nodiscard]] uint8_t getAccountType() const;
+	AccountErrors_t setAccountType(AccountType accountType);
+	[[nodiscard]] AccountType getAccountType() const;
 
 	void updatePremiumTime();
 
-	std::tuple<phmap::flat_hash_map<std::string, uint64_t>, uint8_t> getAccountPlayers() const;
+	std::tuple<phmap::flat_hash_map<std::string, uint64_t>, AccountErrors_t> getAccountPlayers() const;
 
 	// Old protocol compat
 	void setProtocolCompat(bool toggle);

src/account/account_info.hpp

@@ -14,13 +14,15 @@
 	#include <cstdint>
 #endif
 
+#include "enums/account_type.hpp"
+
 struct AccountInfo {
 	~AccountInfo() = default;
 
 	uint32_t id = 0;
 	uint32_t premiumRemainingDays = 0;
 	time_t premiumLastDay = 0;
-	uint8_t accountType = 0;
+	AccountType accountType = ACCOUNT_TYPE_NONE;
 	phmap::flat_hash_map<std::string, uint64_t> players;
 	bool oldProtocol = false;
 	time_t sessionExpires = 0;

src/account/account_repository.hpp

@@ -11,6 +11,9 @@
 
 struct AccountInfo;
 
+enum class CoinType : uint8_t;
+enum class CoinTransactionType : uint8_t;
+
 class AccountRepository {
 public:
 	AccountRepository() = default;
@@ -31,13 +34,13 @@ class AccountRepository {
 
 	virtual bool getPassword(const uint32_t &id, std::string &password) = 0;
 
-	virtual bool getCoins(const uint32_t &id, const uint8_t &type, uint32_t &coins) = 0;
-	virtual bool setCoins(const uint32_t &id, const uint8_t &type, const uint32_t &amount) = 0;
+	virtual bool getCoins(const uint32_t &id, CoinType coinType, uint32_t &coins) = 0;
+	virtual bool setCoins(const uint32_t &id, CoinType coinType, const uint32_t &amount) = 0;
 	virtual bool registerCoinsTransaction(
 		const uint32_t &id,
-		uint8_t type,
+		CoinTransactionType type,
 		uint32_t coins,
-		const uint8_t &coinType,
+		CoinType coinType,
 		const std::string &description
 	) = 0;
 };