[Windows] - Use _mkgmtime instead of timegm

src/api-objects/include/apikey.hpp

@@ -5,36 +5,28 @@
 
 #include "accountowner.hpp"
 #include "cct_string.hpp"
-#include "cct_type_traits.hpp"
 
 namespace cct::api {
 
 class APIKey {
  public:
   /// @brief Creates an API key without an associated name.
-  /// @param platform name of the platform exchange in lower case
   /// @param name name of the key as defined in the secret json file
   /// @param key the public api key
   /// @param privateKey the private api key
   /// @param passphrase passphrase used
-  APIKey(std::string_view platform, std::string_view name, string &&key, string &&privateKey, string &&passphrase)
-      : _platform(platform),
-        _name(name),
-        _key(std::move(key)),
-        _privateKey(std::move(privateKey)),
-        _passphrase(std::move(passphrase)) {}
+  APIKey(std::string_view name, string &&key, string &&privateKey, string &&passphrase)
+      : _name(name), _key(std::move(key)), _privateKey(std::move(privateKey)), _passphrase(std::move(passphrase)) {}
 
   /// @brief Creates an API key with an associated AccountOwner, needed for Bithumb withdrawals for instance.
-  /// @param platform name of the platform exchange in lower case
   /// @param name name of the key as defined in the secret json file
   /// @param key the public api key
   /// @param privateKey the private api key
   /// @param passphrase passphrase used
   /// @param accountOwner the person's name spelled in English that owns the account associated to the key
-  APIKey(std::string_view platform, std::string_view name, string &&key, string &&privateKey, string &&passphrase,
+  APIKey(std::string_view name, string &&key, string &&privateKey, string &&passphrase,
          const AccountOwner &accountOwner)
-      : _platform(platform),
-        _name(name),
+      : _name(name),
         _key(std::move(key)),
         _privateKey(std::move(privateKey)),
         _passphrase(std::move(passphrase)),
@@ -52,18 +44,13 @@ class APIKey {
     _passphrase.assign(_passphrase.size(), '\0');
   }
 
-  std::string_view platform() const { return _platform; }
   std::string_view name() const { return _name; }
   std::string_view key() const { return _key; }
   std::string_view privateKey() const { return _privateKey; }
   std::string_view passphrase() const { return _passphrase; }
   const AccountOwner &accountOwner() const { return _accountOwner; }
 
-  using trivially_relocatable =
-      std::bool_constant<is_trivially_relocatable_v<string> && is_trivially_relocatable_v<AccountOwner>>::type;
-
  private:
-  string _platform;
   string _name;
   string _key;
   string _privateKey;

src/api-objects/src/apikeysprovider.cpp

@@ -52,20 +52,18 @@ APIKeysProvider::KeyNames APIKeysProvider::getKeyNames(ExchangeNameEnum exchange
 }
 
 const APIKey& APIKeysProvider::get(const ExchangeName& exchangeName) const {
-  std::string_view platformStr = exchangeName.name();
-  ExchangeNameEnum exchangeNameEnum = static_cast<ExchangeNameEnum>(
-      std::ranges::find(kSupportedExchanges, platformStr) - std::begin(kSupportedExchanges));
+  ExchangeNameEnum exchangeNameEnum = exchangeName.exchangeNameEnum();
   const APIKeys& apiKeys = _apiKeysPerExchange[static_cast<int>(exchangeNameEnum)];
   if (!exchangeName.isKeyNameDefined()) {
     if (apiKeys.size() > 1) {
-      throw exception("Specify name for {} keys as you have several", platformStr);
+      throw exception("Specify name for {} keys as you have several", exchangeName.name());
     }
     return apiKeys.front();
   }
   auto keyNameIt = std::ranges::find_if(
       apiKeys, [exchangeName](const APIKey& apiKey) { return apiKey.name() == exchangeName.keyName(); });
   if (keyNameIt == apiKeys.end()) {
-    throw exception("Unable to retrieve private key for {} named {:k}", platformStr, exchangeName);
+    throw exception("Unable to retrieve private key for {} named {:k}", exchangeName.name(), exchangeName);
   }
   return *keyNameIt;
 }
@@ -92,11 +90,10 @@ APIKeysProvider::APIKeysPerExchange APIKeysProvider::ParseAPIKeys(std::string_vi
 
   bool atLeastOneKeyFound = false;
   for (auto& [exchangeNameEnum, apiKeys] : apiKeysPerExchangeMap) {
-    auto publicExchangeName = kSupportedExchanges[static_cast<int>(exchangeNameEnum)];
     if (std::ranges::any_of(exchangesWithoutSecrets, [exchangeNameEnum](const auto& exchangeName) {
           return exchangeName.exchangeNameEnum() == exchangeNameEnum;
         })) {
-      log::debug("Not loading {} private keys as requested", publicExchangeName);
+      log::debug("Not loading {} private keys as requested", EnumToString(exchangeNameEnum));
       continue;
     }
 
@@ -107,7 +104,7 @@ APIKeysProvider::APIKeysPerExchange APIKeysProvider::ParseAPIKeys(std::string_vi
       }
 
       apiKeysPerExchange[static_cast<int>(exchangeNameEnum)].emplace_back(
-          publicExchangeName, keyName, std::move(apiKey.key), std::move(apiKey.priv), std::move(apiKey.passphrase),
+          keyName, std::move(apiKey.key), std::move(apiKey.priv), std::move(apiKey.passphrase),
           AccountOwner(apiKey.accountOwner.enName, apiKey.accountOwner.koName));
 
       atLeastOneKeyFound = true;
@@ -138,7 +135,7 @@ string APIKeysProvider::str() const {
     }
     foundKeysStr.push_back('}');
     foundKeysStr.push_back('@');
-    foundKeysStr.append(kSupportedExchanges[exchangePos]);
+    foundKeysStr.append(EnumToString(static_cast<ExchangeNameEnum>(exchangePos)));
   }
   return foundKeysStr;
 }

src/api/common/include/exchangepublicapi.hpp

@@ -125,7 +125,7 @@ class ExchangePublic : public CacheFileUpdatorInterface {
   ExchangeNameEnum exchangeNameEnum() const { return _exchangeNameEnum; }
 
   /// Get the name of the exchange in lower case.
-  std::string_view name() const { return kSupportedExchanges[static_cast<int>(_exchangeNameEnum)]; }
+  std::string_view name() const { return EnumToString(_exchangeNameEnum); }
 
   /// Retrieve the shortest array of markets that can convert 'fromCurrencyCode' to 'toCurrencyCode' (shortest in terms
   /// of number of conversions) of 'fromCurrencyCode' to 'toCurrencyCode'.

src/api/common/src/commonapi.cpp

@@ -78,7 +78,7 @@ MonetaryAmountByCurrencySet CommonAPI::tryQueryWithdrawalFees(ExchangeNameEnum e
 
   if (ret.empty()) {
     log::warn("Taking binance withdrawal fees for {} as crawler failed to retrieve data",
-              kSupportedExchanges[static_cast<int>(exchangeNameEnum)]);
+              EnumToString(exchangeNameEnum));
     ret = _binanceGlobalInfos.queryWithdrawalFees();
   }
   return ret;
@@ -95,7 +95,7 @@ std::optional<MonetaryAmount> CommonAPI::tryQueryWithdrawalFee(ExchangeNameEnum
     }
   }
   log::warn("Taking binance withdrawal fee for {} and currency {} as crawler failed to retrieve data",
-            kSupportedExchanges[static_cast<int>(exchangeNameEnum)], currencyCode);
+            EnumToString(exchangeNameEnum), currencyCode);
   MonetaryAmount withdrawFee = _binanceGlobalInfos.queryWithdrawalFee(currencyCode);
   if (withdrawFee.isDefault()) {
     return {};
@@ -226,7 +226,7 @@ void CommonAPI::updateCacheFile() const {
         fiatsData.fiats.emplace_back(fiatCode.str());
       }
       fiatsData.timeepoch = TimestampToSecondsSinceEpoch(fiatsPtrLastUpdatedTimePair.second);
-      fiatsCacheFile.write(WriteMiniJsonOrThrow(fiatsData));
+      fiatsCacheFile.write(WriteJsonOrThrow(fiatsData));
     }
   }
 

src/api/common/src/fiatconverter.cpp

@@ -62,7 +62,7 @@ FiatConverter::FiatConverter(const CoincenterInfo& coincenterInfo, Duration rate
 }
 
 void FiatConverter::updateCacheFile() const {
-  auto dataStr = WriteMiniJsonOrThrow(_pricesMap);
+  auto dataStr = WriteJsonOrThrow(_pricesMap);
   GetRatesCacheFile(_dataDir).write(dataStr);
 }
 

src/api/common/src/withdrawalfees-crawler.cpp

@@ -55,7 +55,7 @@ WithdrawalFeesCrawler::WithdrawalFeesCrawler(const CoincenterInfo& coincenterInf
       // we can reuse file data
       WithdrawalInfoMaps withdrawalInfoMaps;
 
-      std::string_view exchangeName = kSupportedExchanges[static_cast<int>(exchangeNameEnum)];
+      std::string_view exchangeName = EnumToString(exchangeNameEnum);
 
       for (const auto& [cur, val] : exchangeData.assets) {
         MonetaryAmount withdrawMin(val.min, cur);
@@ -106,7 +106,7 @@ WithdrawalFeesCrawler::WithdrawalInfoMaps WithdrawalFeesCrawler::WithdrawalFeesF
   }
 
   if (withdrawFees1.empty() || withdrawMinMap1.empty()) {
-    log::error("Unable to parse {} withdrawal fees", kSupportedExchanges[static_cast<int>(exchangeNameEnum)]);
+    log::error("Unable to parse {} withdrawal fees", EnumToString(exchangeNameEnum));
   }
 
   return std::make_pair(std::move(withdrawFees1), std::move(withdrawMinMap1));
@@ -136,14 +136,14 @@ void WithdrawalFeesCrawler::updateCacheFile() const {
       }
     }
   }
-  auto dataStr = WriteMiniJsonOrThrow(withdrawInfoFile);
+  auto dataStr = WriteJsonOrThrow(withdrawInfoFile);
 
   GetWithdrawInfoFile(_coincenterInfo.dataDir()).write(dataStr);
 }
 
 WithdrawalFeesCrawler::WithdrawalInfoMaps WithdrawalFeesCrawler::WithdrawalFeesFunc::get1(
     ExchangeNameEnum exchangeNameEnum) {
-  std::string_view exchangeName = kSupportedExchanges[static_cast<int>(exchangeNameEnum)];
+  std::string_view exchangeName = EnumToString(exchangeNameEnum);
   string path(exchangeName);
   path.append(".json");
   std::string_view dataStr = _curlHandle1.query(path, CurlOptions(HttpRequestType::kGet));
@@ -186,7 +186,7 @@ WithdrawalFeesCrawler::WithdrawalInfoMaps WithdrawalFeesCrawler::WithdrawalFeesF
 
 WithdrawalFeesCrawler::WithdrawalInfoMaps WithdrawalFeesCrawler::WithdrawalFeesFunc::get2(
     ExchangeNameEnum exchangeNameEnum) {
-  std::string_view exchangeName = kSupportedExchanges[static_cast<int>(exchangeNameEnum)];
+  std::string_view exchangeName = EnumToString(exchangeNameEnum);
   std::string_view withdrawalFeesCsv = _curlHandle2.query(exchangeName, CurlOptions(HttpRequestType::kGet));
 
   static constexpr std::string_view kBeginTableTitle = "Deposit & Withdrawal fees</h2>";

src/api/common/test/exchangeprivateapi_test.cpp

@@ -94,7 +94,7 @@ class ExchangePrivateTest : public ::testing::Test {
   FiatConverter fiatConverter{coincenterInfo, Duration::max(), Reader(), Reader()};
 
   MockExchangePublic exchangePublic{ExchangeNameEnum::binance, fiatConverter, commonAPI, coincenterInfo};
-  APIKey key{"test", "testUser", "", "", ""};
+  APIKey key{"testUser", "", "", ""};
   MockExchangePrivate exchangePrivate{exchangePublic, coincenterInfo, key};
 
   Market market{"ETH", "EUR"};

src/api/common/test/fiatconverter_test.cpp

@@ -86,7 +86,7 @@ std::string_view CurlHandle::query([[maybe_unused]] std::string_view endpoint, c
       }
     }
     if (res.val != 0) {
-      _queryData = WriteMiniJsonOrThrow(response);
+      _queryData = WriteJsonOrThrow(response);
     }
 
   } else {
@@ -96,7 +96,7 @@ std::string_view CurlHandle::query([[maybe_unused]] std::string_view endpoint, c
     response.rates["SUSHI"] = 36.78;
     response.rates["KRW"] = 1341.88;
     response.rates["NOK"] = 11.3375;
-    _queryData = WriteMiniJsonOrThrow(response);
+    _queryData = WriteJsonOrThrow(response);
   }
 
   return _queryData;

src/api/exchanges/src/binanceprivateapi.cpp

@@ -232,7 +232,7 @@ T PrivateQuery(CurlHandle& curlHandle, const APIKey& apiKey, HttpRequestType req
   }
   if (throwIfError) {
     std::string_view errorMsg;
-    string jsonStr = WriteMiniJsonOrThrow(ret);
+    string jsonStr = WriteJsonOrThrow(ret);
     if constexpr (amc::is_detected<schema::binance::has_msg_t, T>::value) {
       if (ret.msg) {
         errorMsg = *ret.msg;

src/api/exchanges/src/bithumbprivateapi.cpp

@@ -1095,7 +1095,7 @@ InitiatedWithdrawInfo BithumbPrivate::launchWithdraw(MonetaryAmount grossAmount,
 }
 
 void BithumbPrivate::updateCacheFile() const {
-  GetBithumbCurrencyInfoMapCache(_coincenterInfo.dataDir()).write(WriteMiniJsonOrThrow(_currencyOrderInfoMap));
+  GetBithumbCurrencyInfoMapCache(_coincenterInfo.dataDir()).write(WriteJsonOrThrow(_currencyOrderInfoMap));
 }
 
 }  // namespace cct::api

src/api/interface/include/exchangeretriever.hpp

@@ -90,7 +90,7 @@ class ExchangeRetriever {
             }
             if (ret.size() == oldSize) {
               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)]);
+                throw exception("Unable to find {} in the exchange list", EnumToString(name));
               } else {
                 throw exception("Unable to find {} in the exchange list", name);
               }

src/api/interface/src/exchange.cpp

@@ -24,7 +24,7 @@ Exchange::Exchange(const schema::ExchangeConfig &exchangeConfig, ExchangePublic
       _exchangePrivate(std::move(exchangePrivate)),
       _pExchangeConfig(std::addressof(exchangeConfig)) {}
 
-std::size_t Exchange::publicExchangePos() const { return PublicExchangePos(name()); }
+std::size_t Exchange::publicExchangePos() const { return static_cast<std::size_t>(exchangeNameEnum()); }
 
 bool Exchange::canWithdraw(CurrencyCode currencyCode, const CurrencyExchangeFlatSet &currencyExchangeSet) const {
   if (_pExchangeConfig->asset.withdrawExclude.contains(currencyCode)) {

src/api/interface/test/exchangeretriever_test.cpp

@@ -40,8 +40,8 @@ class ExchangeRetrieverTest : public ::testing::Test {
   api::MockExchangePublic exchangePublic1{ExchangeNameEnum::bithumb, fiatConverter, commonAPI, coincenterInfo};
   api::MockExchangePublic exchangePublic2{ExchangeNameEnum::kraken, fiatConverter, commonAPI, coincenterInfo};
   api::MockExchangePublic exchangePublic3{ExchangeNameEnum::kucoin, fiatConverter, commonAPI, coincenterInfo};
-  api::APIKey key1{"test1", "user1", "", "", ""};
-  api::APIKey key2{"test2", "user2", "", "", ""};
+  api::APIKey key1{"user1", "", "", ""};
+  api::APIKey key2{"user2", "", "", ""};
   Exchange exchange1{coincenterInfo.exchangeConfig(exchangePublic1.exchangeNameEnum()), exchangePublic1,
                      std::make_unique<api::MockExchangePrivate>(exchangePublic1, coincenterInfo, key1)};
   Exchange exchange2{coincenterInfo.exchangeConfig(exchangePublic2.exchangeNameEnum()), exchangePublic2,

src/basic-objects/include/coincentercommandtype.hpp

@@ -17,8 +17,6 @@ namespace cct {
 
 enum class CoincenterCommandType : int8_t { CCT_COINCENTER_COMMAND_TYPES };
 
-std::string_view CoincenterCommandTypeToString(CoincenterCommandType coincenterCommandType);
-
 bool IsAnyTrade(CoincenterCommandType coincenterCommandType);
 }  // namespace cct
 

src/basic-objects/src/coincentercommandtype.cpp

@@ -3,15 +3,8 @@
 #include <string_view>
 #include <type_traits>
 
-#include "cct_json.hpp"
-
 namespace cct {
 
-std::string_view CoincenterCommandTypeToString(CoincenterCommandType coincenterCommandType) {
-  return json::reflect<CoincenterCommandType>::keys[static_cast<std::underlying_type_t<CoincenterCommandType>>(
-      coincenterCommandType)];
-}
-
 bool IsAnyTrade(CoincenterCommandType coincenterCommandType) {
   switch (coincenterCommandType) {
     case CoincenterCommandType::Trade:

src/engine/include/exchangesorchestrator.hpp

@@ -97,7 +97,7 @@ class ExchangesOrchestrator {
   MonetaryAmountPerExchange getLastPricePerExchange(Market mk, ExchangeNameSpan exchangeNames);
 
   MarketDataPerExchange getMarketDataPerExchange(std::span<const Market> marketPerPublicExchange,
-                                                 ExchangeNameSpan exchangeNames);
+                                                 std::span<const ExchangeNameEnum> exchangeNameEnums);
 
   MarketTimestampSetsPerExchange pullAvailableMarketsForReplay(TimeWindow timeWindow, ExchangeNameSpan exchangeNames);
 

src/engine/include/queryresultprinter.hpp

@@ -121,17 +121,17 @@ class QueryResultPrinter {
 
   void printJson(const auto &jsonObj) const {
     if (_pOs != nullptr) {
-      *_pOs << WriteMiniJsonOrThrow(jsonObj) << '\n';
+      *_pOs << WriteJsonOrThrow(jsonObj) << '\n';
     } else {
-      _outputLogger->info(WriteMiniJsonOrThrow(jsonObj));
+      _outputLogger->info(WriteJsonOrThrow(jsonObj));
     }
   }
 
   void logActivity(CoincenterCommandType commandType, const auto &jsonObj, bool isSimulationMode = false) const {
     if (_loggingInfo.isCommandTypeTracked(commandType) &&
         (!isSimulationMode || _loggingInfo.alsoLogActivityForSimulatedCommands())) {
       File activityFile = _loggingInfo.getActivityFile();
-      activityFile.write(WriteMiniJsonOrThrow(jsonObj), Writer::Mode::Append);
+      activityFile.write(WriteJsonOrThrow(jsonObj), Writer::Mode::Append);
     }
   }
 

src/engine/src/coincenter.cpp

@@ -73,18 +73,18 @@ MarketOrderBookConversionRates Coincenter::getMarketOrderBooks(Market mk, Exchan
 }
 
 MarketDataPerExchange Coincenter::queryMarketDataPerExchange(std::span<const Market> marketPerPublicExchangePos) {
-  ExchangeNames exchangeNames;
+  ExchangeNameEnumVector exchangeNameEnums;
 
   int exchangePos{};
   for (Market market : marketPerPublicExchangePos) {
     if (market.isDefined()) {
-      exchangeNames.emplace_back(kSupportedExchanges[exchangePos]);
+      exchangeNameEnums.emplace_back(static_cast<ExchangeNameEnum>(exchangePos));
     }
     ++exchangePos;
   }
 
   const auto marketDataPerExchange =
-      _exchangesOrchestrator.getMarketDataPerExchange(marketPerPublicExchangePos, exchangeNames);
+      _exchangesOrchestrator.getMarketDataPerExchange(marketPerPublicExchangePos, exchangeNameEnums);
 
   // Transform data structures to export metrics input format
   MarketOrderBookConversionRates marketOrderBookConversionRates(marketDataPerExchange.size());
@@ -390,8 +390,7 @@ Coincenter::MarketTraderEngineVector Coincenter::createMarketTraderEngines(
 
     if (!isValidateOnly && (startBaseAmount == 0 || startQuoteAmount == 0)) {
       log::warn("Cannot convert to start base / quote amounts for {} ({} / {})",
-                kSupportedExchanges[static_cast<int>(exchangesWithThisMarketData[exchangePos])], startBaseAmount,
-                startQuoteAmount);
+                EnumToString(exchangesWithThisMarketData[exchangePos]), startBaseAmount, startQuoteAmount);
       exchangesWithThisMarketData.erase(exchangesWithThisMarketData.begin() + exchangePos);
       convertedBaseAmountPerExchange.erase(convertedBaseAmountPerExchange.begin() + exchangePos);
       convertedQuoteAmountPerExchange.erase(convertedQuoteAmountPerExchange.begin() + exchangePos);

src/engine/src/exchangesorchestrator.cpp

@@ -954,9 +954,9 @@ MonetaryAmountPerExchange ExchangesOrchestrator::getLastPricePerExchange(Market
   return lastPricePerExchange;
 }
 
-MarketDataPerExchange ExchangesOrchestrator::getMarketDataPerExchange(std::span<const Market> marketPerPublicExchange,
-                                                                      ExchangeNameSpan exchangeNames) {
-  UniquePublicSelectedExchanges selectedExchanges = _exchangeRetriever.selectOneAccount(exchangeNames);
+MarketDataPerExchange ExchangesOrchestrator::getMarketDataPerExchange(
+    std::span<const Market> marketPerPublicExchange, std::span<const ExchangeNameEnum> exchangeNameEnums) {
+  UniquePublicSelectedExchanges selectedExchanges = _exchangeRetriever.selectOneAccount(exchangeNameEnums);
 
   std::array<bool, kNbSupportedExchanges> isMarketTradable;
 

src/engine/src/metricsexporter.cpp

@@ -95,7 +95,7 @@ void MetricsExporter::exportOrderbookMetrics(const MarketOrderBookConversionRate
 
   for (const auto &[exchangeNameEnum, marketOrderBook, optConversionRate] : marketOrderBookConversionRates) {
     key.set("market", marketOrderBook.market().assetsPairStrLower('-'));
-    key.set("exchange", kSupportedExchanges[static_cast<int>(exchangeNameEnum)]);
+    key.set("exchange", EnumToString(exchangeNameEnum));
     key.set("side", "ask");
     _pMetricsGateway->add(MetricType::kGauge, MetricOperation::kSet, key, marketOrderBook.lowestAskPrice().toDouble());
     key.set("side", "bid");
@@ -105,7 +105,7 @@ void MetricsExporter::exportOrderbookMetrics(const MarketOrderBookConversionRate
   key.set(kMetricHelpKey, "Best bids and asks volumes");
   for (const auto &[exchangeNameEnum, marketOrderBook, optConversionRate] : marketOrderBookConversionRates) {
     key.set("market", marketOrderBook.market().assetsPairStrLower('-'));
-    key.set("exchange", kSupportedExchanges[static_cast<int>(exchangeNameEnum)]);
+    key.set("exchange", EnumToString(exchangeNameEnum));
     key.set("side", "ask");
     _pMetricsGateway->add(MetricType::kGauge, MetricOperation::kSet, key,
                           marketOrderBook.amountAtAskPrice().toDouble());