[Code refactoring] - Use ExchangeNameEnum instead of string_view in E…

…xchangePublic

src/api-objects/include/apikeysprovider.hpp

@@ -23,17 +23,19 @@ class APIKeysProvider {
 
   APIKeysProvider(std::string_view dataDir, const ExchangeSecretsInfo &exchangeSecretsInfo, settings::RunMode runMode);
 
-  KeyNames getKeyNames(std::string_view platform) const;
+  KeyNames getKeyNames(ExchangeNameEnum exchangeNameEnum) const;
 
-  bool contains(std::string_view platform) const { return _apiKeysMap.find(platform) != _apiKeysMap.end(); }
+  bool contains(ExchangeNameEnum exchangeNameEnum) const {
+    return _apiKeysMap.find(exchangeNameEnum) != _apiKeysMap.end();
+  }
 
   const APIKey &get(const ExchangeName &exchangeName) const;
 
   string str() const;
 
  private:
   using APIKeys = vector<APIKey>;
-  using APIKeysMap = std::map<string, APIKeys, std::less<>>;
+  using APIKeysMap = std::map<ExchangeNameEnum, APIKeys>;
 
   static APIKeysMap ParseAPIKeys(std::string_view dataDir, const ExchangeSecretsInfo &exchangeSecretsInfo,
                                  settings::RunMode runMode);

src/api-objects/src/apikeysprovider.cpp

@@ -40,9 +40,9 @@ APIKeysProvider::APIKeysProvider(std::string_view dataDir, const ExchangeSecrets
   }
 }
 
-APIKeysProvider::KeyNames APIKeysProvider::getKeyNames(std::string_view platform) const {
+APIKeysProvider::KeyNames APIKeysProvider::getKeyNames(ExchangeNameEnum exchangeNameEnum) const {
   KeyNames keyNames;
-  auto foundIt = _apiKeysMap.find(platform);
+  auto foundIt = _apiKeysMap.find(exchangeNameEnum);
   if (foundIt != _apiKeysMap.end()) {
     const APIKeys& apiKeys = foundIt->second;
     std::ranges::transform(apiKeys, std::back_inserter(keyNames), [](const APIKey& apiKey) { return apiKey.name(); });
@@ -52,7 +52,10 @@ APIKeysProvider::KeyNames APIKeysProvider::getKeyNames(std::string_view platform
 
 const APIKey& APIKeysProvider::get(const ExchangeName& exchangeName) const {
   std::string_view platformStr = exchangeName.name();
-  auto foundIt = _apiKeysMap.find(platformStr);
+  ExchangeNameEnum exchangeNameEnum = static_cast<ExchangeNameEnum>(
+      std::find(std::begin(kSupportedExchanges), std::end(kSupportedExchanges), platformStr) -
+      std::begin(kSupportedExchanges));
+  auto foundIt = _apiKeysMap.find(exchangeNameEnum);
   if (foundIt == _apiKeysMap.end()) {
     throw exception("Unable to retrieve private key for {}", platformStr);
   }
@@ -89,6 +92,10 @@ APIKeysProvider::APIKeysMap APIKeysProvider::ParseAPIKeys(std::string_view dataD
         log::info("Not loading {} private keys as requested", publicExchangeName);
         continue;
       }
+      ExchangeNameEnum exchangeNameEnum = static_cast<ExchangeNameEnum>(
+          std::find(std::begin(kSupportedExchanges), std::end(kSupportedExchanges), publicExchangeName) -
+          std::begin(kSupportedExchanges));
+
       for (auto& [name, keySecretObj] : keyObj.items()) {
         auto keyIt = keySecretObj.find("key");
         auto privateIt = keySecretObj.find("private");
@@ -115,9 +122,9 @@ APIKeysProvider::APIKeysMap APIKeysProvider::ParseAPIKeys(std::string_view dataD
           }
         }
 
-        map[publicExchangeName].emplace_back(publicExchangeName, name, std::move(keyIt->get_ref<string&>()),
-                                             std::move(privateIt->get_ref<string&>()), std::move(passphrase),
-                                             AccountOwner(ownerEnName, ownerKoName));
+        map[exchangeNameEnum].emplace_back(publicExchangeName, name, std::move(keyIt->get_ref<string&>()),
+                                           std::move(privateIt->get_ref<string&>()), std::move(passphrase),
+                                           AccountOwner(ownerEnName, ownerKoName));
       }
     }
     if (map.empty()) {
@@ -149,7 +156,7 @@ string APIKeysProvider::str() const {
       foundKeysStr.push_back('}');
     }
     foundKeysStr.push_back('@');
-    foundKeysStr.append(platform);
+    foundKeysStr.append(kSupportedExchanges[static_cast<int>(platform)]);
   }
   return foundKeysStr;
 }

src/api/common/include/exchangeprivateapi.hpp

@@ -124,9 +124,9 @@ class ExchangePrivate : public CacheFileUpdatorInterface {
   TradedAmountsVectorWithFinalAmount queryDustSweeper(CurrencyCode currencyCode);
 
   /// Builds an ExchangeName wrapping the exchange and the key name
-  ExchangeName exchangeName() const { return {_exchangePublic.name(), _apiKey.name()}; }
+  ExchangeName exchangeName() const { return ExchangeName(_exchangePublic.exchangeNameEnum(), _apiKey.name()); }
 
-  const ExchangeConfig &exchangeConfig() const { return _exchangePublic.exchangeConfig(); }
+  const auto &exchangeConfig() const { return _exchangePublic.exchangeConfig(); }
 
  protected:
   ExchangePrivate(const CoincenterInfo &coincenterInfo, ExchangePublic &exchangePublic, const APIKey &apiKey);

src/api/common/src/exchangeprivateapi.cpp

@@ -586,7 +586,7 @@ PlaceOrderInfo ExchangePrivate::computeSimulatedMatchedPlacedOrderInfo(MonetaryA
   const bool isSell = tradeInfo.tradeContext.side == TradeSide::kSell;
 
   MonetaryAmount toAmount = isSell ? volume.convertTo(price) : volume;
-  ExchangeConfig::FeeType feeType = isTakerStrategy ? ExchangeConfig::FeeType::kTaker : ExchangeConfig::FeeType::kMaker;
+  auto feeType = isTakerStrategy ? ExchangeConfig::FeeType::kTaker : ExchangeConfig::FeeType::kMaker;
   toAmount = _coincenterInfo.exchangeConfig(_exchangePublic.name()).applyFee(toAmount, feeType);
   PlaceOrderInfo placeOrderInfo(OrderInfo(TradedAmounts(isSell ? volume : volume.toNeutral() * price, toAmount)),
                                 OrderId("SimulatedOrderId"));

src/api/exchanges/src/binanceprivateapi.cpp

@@ -289,7 +289,7 @@ Wallet BinancePrivate::DepositWalletFunc::operator()(CurrencyCode currencyCode)
   const CoincenterInfo& coincenterInfo = _exchangePublic.coincenterInfo();
   bool doCheckWallet = coincenterInfo.exchangeConfig(_exchangePublic.name()).validateDepositAddressesInFile();
   WalletCheck walletCheck(coincenterInfo.dataDir(), doCheckWallet);
-  Wallet wallet(ExchangeName(_exchangePublic.name(), _apiKey.name()), currencyCode,
+  Wallet wallet(ExchangeName(_exchangePublic.exchangeNameEnum(), _apiKey.name()), currencyCode,
                 std::move(result["address"].get_ref<string&>()), tag, walletCheck, _apiKey.accountOwner());
   log::info("Retrieved {} (URL: '{}')", wallet, result["url"].get<std::string_view>());
   return wallet;

src/api/exchanges/src/bithumbprivateapi.cpp

@@ -410,8 +410,8 @@ Wallet BithumbPrivate::DepositWalletFunc::operator()(CurrencyCode currencyCode)
   const CoincenterInfo& coincenterInfo = _exchangePublic.coincenterInfo();
   bool doCheckWallet = coincenterInfo.exchangeConfig(_exchangePublic.name()).validateDepositAddressesInFile();
   WalletCheck walletCheck(coincenterInfo.dataDir(), doCheckWallet);
-  Wallet wallet(ExchangeName(_exchangePublic.name(), _apiKey.name()), currencyCode, string(address), tag, walletCheck,
-                _apiKey.accountOwner());
+  Wallet wallet(ExchangeName(_exchangePublic.exchangeNameEnum(), _apiKey.name()), currencyCode, string(address), tag,
+                walletCheck, _apiKey.accountOwner());
   log::info("Retrieved {}", wallet);
   return wallet;
 }
@@ -867,9 +867,8 @@ PlaceOrderInfo BithumbPrivate::placeOrder(MonetaryAmount /*from*/, MonetaryAmoun
 
   // Volume is gross amount if from amount is in quote currency, we should remove the fees
   if (fromCurrencyCode == mk.quote()) {
-    ExchangeConfig::FeeType feeType =
-        isTakerStrategy ? ExchangeConfig::FeeType::kTaker : ExchangeConfig::FeeType::kMaker;
-    const ExchangeConfig& exchangeConfig = _coincenterInfo.exchangeConfig(_exchangePublic.name());
+    const auto feeType = isTakerStrategy ? ExchangeConfig::FeeType::kTaker : ExchangeConfig::FeeType::kMaker;
+    const auto& exchangeConfig = _coincenterInfo.exchangeConfig(_exchangePublic.name());
     volume = exchangeConfig.applyFee(volume, feeType);
   }
 

src/api/exchanges/src/huobiprivateapi.cpp

@@ -194,7 +194,7 @@ Wallet HuobiPrivate::DepositWalletFunc::operator()(CurrencyCode currencyCode) {
 
   string address;
   std::string_view tag;
-  ExchangeName exchangeName(_huobiPublic.name(), _apiKey.name());
+  ExchangeName exchangeName(_huobiPublic.exchangeNameEnum(), _apiKey.name());
   const CoincenterInfo& coincenterInfo = _huobiPublic.coincenterInfo();
   bool doCheckWallet = coincenterInfo.exchangeConfig(_huobiPublic.name()).validateDepositAddressesInFile();
   WalletCheck walletCheck(coincenterInfo.dataDir(), doCheckWallet);

src/api/exchanges/src/krakenprivateapi.cpp

@@ -199,7 +199,7 @@ BalancePortfolio KrakenPrivate::queryAccountBalance(const BalanceOptions& balanc
 Wallet KrakenPrivate::DepositWalletFunc::operator()(CurrencyCode currencyCode) {
   CurrencyExchange krakenCurrency = _exchangePublic.convertStdCurrencyToCurrencyExchange(currencyCode);
   auto [res, err] = PrivateQuery(_curlHandle, _apiKey, "/private/DepositMethods", {{"asset", krakenCurrency.altStr()}});
-  ExchangeName eName(_exchangePublic.name(), _apiKey.name());
+  ExchangeName eName(_exchangePublic.exchangeNameEnum(), _apiKey.name());
   if (res.empty()) {
     throw exception("No deposit method found on {} for {}", eName, currencyCode);
   }

src/api/exchanges/src/kucoinprivateapi.cpp

@@ -198,7 +198,7 @@ BalancePortfolio KucoinPrivate::queryAccountBalance(const BalanceOptions& balanc
 Wallet KucoinPrivate::DepositWalletFunc::operator()(CurrencyCode currencyCode) {
   json::container result = PrivateQuery(_curlHandle, _apiKey, HttpRequestType::kGet, "/api/v2/deposit-addresses",
                                         {{"currency", currencyCode.str()}})["data"];
-  ExchangeName exchangeName(_kucoinPublic.name(), _apiKey.name());
+  ExchangeName exchangeName(_kucoinPublic.exchangeNameEnum(), _apiKey.name());
   if (result.empty()) {
     log::info("No deposit address for {} in {}, creating one", currencyCode, exchangeName);
     result = PrivateQuery(_curlHandle, _apiKey, HttpRequestType::kPost, "/api/v1/deposit-addresses",

src/api/exchanges/src/upbitprivateapi.cpp

@@ -238,7 +238,7 @@ Wallet UpbitPrivate::DepositWalletFunc::operator()(CurrencyCode currencyCode) {
   const CoincenterInfo& coincenterInfo = _exchangePublic.coincenterInfo();
   bool doCheckWallet = coincenterInfo.exchangeConfig(_exchangePublic.name()).validateDepositAddressesInFile();
   WalletCheck walletCheck(coincenterInfo.dataDir(), doCheckWallet);
-  Wallet wallet(ExchangeName(_exchangePublic.name(), _apiKey.name()), currencyCode,
+  Wallet wallet(ExchangeName(_exchangePublic.exchangeNameEnum(), _apiKey.name()), currencyCode,
                 std::move(addressIt->get_ref<string&>()), tag, walletCheck, _apiKey.accountOwner());
   log::info("Retrieved {}", wallet);
   return wallet;
@@ -554,9 +554,8 @@ void UpbitPrivate::applyFee(Market mk, CurrencyCode fromCurrencyCode, bool isTak
                             MonetaryAmount& volume) {
   if (fromCurrencyCode == mk.quote()) {
     // For 'buy', from amount is fee excluded
-    ExchangeConfig::FeeType feeType =
-        isTakerStrategy ? ExchangeConfig::FeeType::kTaker : ExchangeConfig::FeeType::kMaker;
-    const ExchangeConfig& exchangeConfig = _coincenterInfo.exchangeConfig(_exchangePublic.name());
+    const auto feeType = isTakerStrategy ? ExchangeConfig::FeeType::kTaker : ExchangeConfig::FeeType::kMaker;
+    const auto& exchangeConfig = _coincenterInfo.exchangeConfig(_exchangePublic.name());
     if (isTakerStrategy) {
       from = exchangeConfig.applyFee(from, feeType);
     } else {

src/api/exchanges/test/bithumb_place_order_test.cpp

@@ -43,7 +43,8 @@ class BithumbPrivateAPIPlaceOrderTest : public ::testing::Test {
   CommonAPI commonAPI{coincenterInfo, Duration::max()};
   BithumbPublic exchangePublic{coincenterInfo, fiatConverter, commonAPI};
   APIKeysProvider apiKeysProvider{coincenterInfo.dataDir(), coincenterInfo.getRunMode()};
-  ExchangeName exchangeName{exchangePublic.name(), apiKeysProvider.getKeyNames(exchangePublic.name()).front()};
+  ExchangeName exchangeName{exchangePublic.exchangeNameEnum(),
+                            apiKeysProvider.getKeyNames(exchangePublic.exchangeNameEnum()).front()};
   const APIKey& testKey = apiKeysProvider.get(exchangeName);
   BithumbPrivate exchangePrivate{coincenterInfo, exchangePublic, testKey};
 

src/api/exchanges/test/exchangecommonapi_test.hpp

@@ -299,13 +299,13 @@ class TestAPI {
 
  private:
   void createPrivateExchangeIfKeyPresent() {
-    std::string_view publicExchangeName = exchangePublic.name();
-    if (!apiKeysProvider.contains(publicExchangeName)) {
-      log::warn("Skip {} private API test as cannot find associated private key", publicExchangeName);
+    auto exchangeNameEnum = exchangePublic.exchangeNameEnum();
+    if (!apiKeysProvider.contains(exchangeNameEnum)) {
+      log::warn("Skip {} private API test as cannot find associated private key", exchangePublic.name());
       return;
     }
 
-    ExchangeName exchangeName(publicExchangeName, apiKeysProvider.getKeyNames(publicExchangeName).front());
+    ExchangeName exchangeName(exchangeNameEnum, apiKeysProvider.getKeyNames(exchangeNameEnum).front());
     const APIKey &firstAPIKey = apiKeysProvider.get(exchangeName);
 
     exchangePrivateOpt.emplace(coincenterInfo, exchangePublic, firstAPIKey);

src/api/interface/include/exchange.hpp

@@ -36,15 +36,13 @@ class Exchange : public CacheFileUpdatorInterface {
            std::unique_ptr<ExchangePrivate> exchangePrivate);
 
   std::string_view name() const { return apiPublic().name(); }
+  ExchangeNameEnum exchangeNameEnum() const { return apiPublic().exchangeNameEnum(); }
   std::string_view keyName() const { return apiPrivate().keyName(); }
 
   std::size_t publicExchangePos() const;
 
   ExchangeName createExchangeName() const {
-    if (hasPrivateAPI()) {
-      return {name(), keyName()};
-    }
-    return ExchangeName(name());
+    return ExchangeName(exchangeNameEnum(), hasPrivateAPI() ? keyName() : std::string_view());
   }
 
   ExchangePublic &apiPublic() { return *_pExchangePublic; }

src/api/interface/include/exchangeretriever.hpp

@@ -89,7 +89,11 @@ class ExchangeRetriever {
               ret.push_back(std::addressof(*foundIt));
             }
             if (ret.size() == oldSize) {
-              throw exception("Unable to find {} in the exchange list", name);
+              if constexpr (std::is_same_v<std::remove_cvref_t<decltype(name)>, ExchangeNameEnum>) {
+                throw exception("Unable to find {} in the exchange list", kSupportedExchanges[static_cast<int>(name)]);
+              } else {
+                throw exception("Unable to find {} in the exchange list", name);
+              }
             }
           }
           break;
@@ -103,13 +107,16 @@ class ExchangeRetriever {
 
   template <class NameType>
   struct Matcher {
-    static_assert(std::is_same_v<NameType, ExchangeName> || std::is_same_v<NameType, std::string_view>);
+    static_assert(std::is_same_v<NameType, ExchangeName> || std::is_same_v<NameType, std::string_view> ||
+                  std::is_same_v<NameType, ExchangeNameEnum>);
 
     bool operator()(const Exchange &e, const NameType &n) const {
       if constexpr (std::is_same_v<NameType, std::string_view>) {
         return e.name() == n;
-      } else {
+      } else if constexpr (std::is_same_v<NameType, ExchangeName>) {
         return e.matches(n);
+      } else if constexpr (std::is_same_v<NameType, ExchangeNameEnum>) {
+        return e.exchangeNameEnum() == n;
       }
     }
   };

src/api/interface/src/exchangepool.cpp

@@ -34,30 +34,31 @@ ExchangePool::ExchangePool(const CoincenterInfo& coincenterInfo, FiatConverter&
       _krakenPublic(_coincenterInfo, _fiatConverter, _commonAPI),
       _kucoinPublic(_coincenterInfo, _fiatConverter, _commonAPI),
       _upbitPublic(_coincenterInfo, _fiatConverter, _commonAPI) {
-  for (std::string_view exchangeStr : kSupportedExchanges) {
+  for (int exchangePos = 0; exchangePos < kNbSupportedExchanges; ++exchangePos) {
+    ExchangeNameEnum exchangeNameEnum = static_cast<ExchangeNameEnum>(exchangePos);
     api::ExchangePublic* exchangePublic;
-    if (exchangeStr == "binance") {
+    if (exchangeNameEnum == ExchangeNameEnum::binance) {
       exchangePublic = &_binancePublic;
-    } else if (exchangeStr == "bithumb") {
+    } else if (exchangeNameEnum == ExchangeNameEnum::bithumb) {
       exchangePublic = &_bithumbPublic;
-    } else if (exchangeStr == "huobi") {
+    } else if (exchangeNameEnum == ExchangeNameEnum::huobi) {
       exchangePublic = &_huobiPublic;
-    } else if (exchangeStr == "kraken") {
+    } else if (exchangeNameEnum == ExchangeNameEnum::kraken) {
       exchangePublic = &_krakenPublic;
-    } else if (exchangeStr == "kucoin") {
+    } else if (exchangeNameEnum == ExchangeNameEnum::kucoin) {
       exchangePublic = &_kucoinPublic;
-    } else if (exchangeStr == "upbit") {
+    } else if (exchangeNameEnum == ExchangeNameEnum::upbit) {
       exchangePublic = &_upbitPublic;
     } else {
-      throw exception("Should not happen, unsupported platform {}", exchangeStr);
+      throw exception("Should not happen, unsupported exchange pos {}", exchangePos);
     }
 
-    const bool canUsePrivateExchange = _apiKeyProvider.contains(exchangeStr);
-    const ExchangeConfig& exchangeConfig = _coincenterInfo.exchangeConfig(exchangePublic->name());
+    const bool canUsePrivateExchange = _apiKeyProvider.contains(exchangeNameEnum);
+    const auto& exchangeConfig = _coincenterInfo.exchangeConfig(kSupportedExchanges[exchangePos]);
     if (canUsePrivateExchange) {
-      for (std::string_view keyName : _apiKeyProvider.getKeyNames(exchangeStr)) {
+      for (std::string_view keyName : _apiKeyProvider.getKeyNames(exchangeNameEnum)) {
         std::unique_ptr<api::ExchangePrivate> exchangePrivate;
-        ExchangeName exchangeName(exchangeStr, keyName);
+        ExchangeName exchangeName(exchangeNameEnum, keyName);
         const api::APIKey& apiKey = _apiKeyProvider.get(exchangeName);
         if (exchangePublic == &_binancePublic) {
           exchangePrivate = std::make_unique<api::BinancePrivate>(_coincenterInfo, _binancePublic, apiKey);
@@ -72,7 +73,7 @@ ExchangePool::ExchangePool(const CoincenterInfo& coincenterInfo, FiatConverter&
         } else if (exchangePublic == &_upbitPublic) {
           exchangePrivate = std::make_unique<api::UpbitPrivate>(_coincenterInfo, _upbitPublic, apiKey);
         } else {
-          throw exception("Unsupported platform {}", exchangeStr);
+          throw exception("Should not happen");
         }
 
         if (exchangeConfig.shouldValidateApiKey()) {

src/basic-objects/include/cct_const.hpp

@@ -9,7 +9,9 @@
 
 namespace cct {
 
-enum class ExchangeNameEnum : int8_t { binance, bithumb, huobi, kraken, kucoin, upbit };
+#define CCT_EXCHANGE_NAMES binance, bithumb, huobi, kraken, kucoin, upbit
+
+enum class ExchangeNameEnum : int8_t { CCT_EXCHANGE_NAMES };
 
 static constexpr std::string_view kDefaultDataDir = CCT_DATA_DIR;
 
@@ -35,9 +37,11 @@ template <>
 struct glz::meta<cct::ExchangeNameEnum> {
   using enum cct::ExchangeNameEnum;
 
-  static constexpr auto value = enumerate(binance, bithumb, huobi, kraken, kucoin, upbit);
+  static constexpr auto value = enumerate(CCT_EXCHANGE_NAMES);
 };
 
+#undef CCT_EXCHANGE_NAMES
+
 namespace cct {
 
 /// Ordered list of supported exchange names.