Activate new clang-tidy checks, fix them

.clang-tidy

@@ -5,22 +5,16 @@ Checks: "-*,\
   -bugprone-narrowing-conversions,\
   google-readability-casting,\
   misc-*,\
-  -misc-no-recursion,\
   -misc-non-private-member-variables-in-classes,\
   modernize-*,\
   -modernize-avoid-c-arrays,\
-  -modernize-return-braced-init-list,\
-  -modernize-use-nodiscard,\
-  -modernize-use-noexcept,\
   -modernize-use-trailing-return-type,\
   performance-*,\
   portability-*,\
   readability-*,\
   -readability-function-cognitive-complexity,\
-  -readability-identifier-naming,\
   -readability-magic-numbers,\
   -readability-qualified-auto,\
-  -readability-uppercase-literal-suffix,\
   "
 HeaderFilterRegex: 'Source/cm[^/]*\.(h|hxx|cxx)$'
 CheckOptions:

src/api/common/src/cryptowatchapi.cpp

@@ -27,7 +27,7 @@ const json& CollectResults(const json& dataJson) {
 }
 
 File GetFiatCacheFile(std::string_view dataDir) {
-  return File(dataDir, File::Type::kCache, "fiatcache.json", File::IfError::kNoThrow);
+  return {dataDir, File::Type::kCache, "fiatcache.json", File::IfError::kNoThrow};
 }
 
 constexpr std::string_view kCryptowatchBaseUrl = "https://api.cryptowat.ch";

src/api/common/src/exchangeprivateapi.cpp

@@ -499,8 +499,8 @@ ReceivedWithdrawInfo ExchangePrivate::isWithdrawReceived(
   }
   RecentDeposit expectedDeposit(netEmittedAmount, Clock::now());
   const RecentDeposit *pClosestRecentDeposit = expectedDeposit.selectClosestRecentDeposit(recentDeposits);
-  return ReceivedWithdrawInfo(pClosestRecentDeposit == nullptr ? MonetaryAmount() : pClosestRecentDeposit->amount(),
-                              pClosestRecentDeposit != nullptr);
+  return {pClosestRecentDeposit == nullptr ? MonetaryAmount() : pClosestRecentDeposit->amount(),
+          pClosestRecentDeposit != nullptr};
 }
 
 }  // namespace cct::api

src/api/exchanges/src/binanceprivateapi.cpp

@@ -295,7 +295,7 @@ MonetaryAmount BinancePrivate::WithdrawFeesFunc::operator()(CurrencyCode currenc
   if (!withdrawFeeDetails["withdrawStatus"].get<bool>()) {
     log::error("{} is currently unavailable for withdraw from {}", currencyCode, _exchangePublic.name());
   }
-  return MonetaryAmount(withdrawFeeDetails["withdrawFee"].get<std::string_view>(), currencyCode);
+  return {withdrawFeeDetails["withdrawFee"].get<std::string_view>(), currencyCode};
 }
 
 namespace {
@@ -449,7 +449,7 @@ InitiatedWithdrawInfo BinancePrivate::launchWithdraw(MonetaryAmount grossAmount,
   }
   json result = PrivateQuery(_curlHandle, _apiKey, HttpRequestType::kPost, "/sapi/v1/capital/withdraw/apply",
                              std::move(withdrawPostData));
-  return InitiatedWithdrawInfo(std::move(destinationWallet), std::move(result["id"].get_ref<string&>()), grossAmount);
+  return {std::move(destinationWallet), std::move(result["id"].get_ref<string&>()), grossAmount};
 }
 
 SentWithdrawInfo BinancePrivate::isWithdrawSuccessfullySent(const InitiatedWithdrawInfo& initiatedWithdrawInfo) {
@@ -500,7 +500,7 @@ SentWithdrawInfo BinancePrivate::isWithdrawSuccessfullySent(const InitiatedWithd
       break;
     }
   }
-  return SentWithdrawInfo(netEmittedAmount, fee, isWithdrawSent);
+  return {netEmittedAmount, fee, isWithdrawSent};
 }
 
 ReceivedWithdrawInfo BinancePrivate::isWithdrawReceived(const InitiatedWithdrawInfo& initiatedWithdrawInfo,
@@ -526,8 +526,8 @@ ReceivedWithdrawInfo BinancePrivate::isWithdrawReceived(const InitiatedWithdrawI
   }
   RecentDeposit expectedDeposit(sentWithdrawInfo.netEmittedAmount(), Clock::now());
   const RecentDeposit* pClosestRecentDeposit = expectedDeposit.selectClosestRecentDeposit(recentDeposits);
-  return ReceivedWithdrawInfo(pClosestRecentDeposit == nullptr ? MonetaryAmount() : pClosestRecentDeposit->amount(),
-                              pClosestRecentDeposit != nullptr);
+  return {pClosestRecentDeposit == nullptr ? MonetaryAmount() : pClosestRecentDeposit->amount(),
+          pClosestRecentDeposit != nullptr};
 }
 
 }  // namespace cct::api

src/api/exchanges/src/binancepublicapi.cpp

@@ -53,8 +53,7 @@ const json& RetrieveMarketData(const ExchangeInfoDataByMarket& exchangeInfoData,
 template <class ExchangeInfoDataByMarket>
 VolAndPriNbDecimals QueryVolAndPriNbDecimals(const ExchangeInfoDataByMarket& exchangeInfoData, Market mk) {
   const json& marketData = RetrieveMarketData(exchangeInfoData, mk);
-  return VolAndPriNbDecimals(marketData["baseAssetPrecision"].get<int8_t>(),
-                             marketData["quoteAssetPrecision"].get<int8_t>());
+  return {marketData["baseAssetPrecision"].get<int8_t>(), marketData["quoteAssetPrecision"].get<int8_t>()};
 }
 }  // namespace
 
@@ -450,7 +449,7 @@ MarketOrderBook BinancePublic::OrderBookFunc::operator()(Market mk, int depth) {
 MonetaryAmount BinancePublic::TradedVolumeFunc::operator()(Market mk) {
   json result = PublicQuery(_commonInfo._curlHandle, "/api/v3/ticker/24hr", {{"symbol", mk.assetsPairStrUpper()}});
   std::string_view last24hVol = result["volume"].get<std::string_view>();
-  return MonetaryAmount(last24hVol, mk.base());
+  return {last24hVol, mk.base()};
 }
 
 LastTradesVector BinancePublic::queryLastTrades(Market mk, int nbTrades) {
@@ -478,7 +477,7 @@ LastTradesVector BinancePublic::queryLastTrades(Market mk, int nbTrades) {
 MonetaryAmount BinancePublic::TickerFunc::operator()(Market mk) {
   json result = PublicQuery(_commonInfo._curlHandle, "/api/v3/ticker/price", {{"symbol", mk.assetsPairStrUpper()}});
   std::string_view lastPrice = result["price"].get<std::string_view>();
-  return MonetaryAmount(lastPrice, mk.quote());
+  return {lastPrice, mk.quote()};
 }
 
 }  // namespace cct::api

src/api/exchanges/src/bithumbprivateapi.cpp

@@ -233,7 +233,7 @@ json PrivateQuery(CurlHandle& curlHandle, const APIKey& apiKey, std::string_view
 }
 
 File GetBithumbCurrencyInfoMapCache(std::string_view dataDir) {
-  return File(dataDir, File::Type::kCache, "bithumbcurrencyinfocache.json", File::IfError::kNoThrow);
+  return {dataDir, File::Type::kCache, "bithumbcurrencyinfocache.json", File::IfError::kNoThrow};
 }
 
 }  // namespace
@@ -683,7 +683,7 @@ InitiatedWithdrawInfo BithumbPrivate::launchWithdraw(MonetaryAmount grossAmount,
     withdrawPostData.append("destination", destinationWallet.tag());
   }
   PrivateQuery(_curlHandle, _apiKey, "/trade/btc_withdrawal", std::move(withdrawPostData));
-  return InitiatedWithdrawInfo(std::move(destinationWallet), "", grossAmount);
+  return {std::move(destinationWallet), "", grossAmount};
 }
 
 SentWithdrawInfo BithumbPrivate::isWithdrawSuccessfullySent(const InitiatedWithdrawInfo& initiatedWithdrawInfo) {
@@ -708,7 +708,7 @@ SentWithdrawInfo BithumbPrivate::isWithdrawSuccessfullySent(const InitiatedWithd
       MonetaryAmount consumedAmt(std::string_view(unitsStr.begin() + first, unitsStr.end()), currencyCode);
       if (consumedAmt == initiatedWithdrawInfo.grossEmittedAmount()) {
         bool isWithdrawSuccess = searchGb == 5;
-        return SentWithdrawInfo(initiatedWithdrawInfo.grossEmittedAmount() - realFee, realFee, isWithdrawSuccess);
+        return {initiatedWithdrawInfo.grossEmittedAmount() - realFee, realFee, isWithdrawSuccess};
       }
       // TODO: Could we have rounding issues in case Bithumb returns to us a string representation of an amount coming
       // from a double? In this case, we should offer a security interval, for instance, accepting +- 1 % error.

src/api/exchanges/src/bithumbpublicapi.cpp

@@ -295,7 +295,7 @@ MonetaryAmount BithumbPublic::TradedVolumeFunc::operator()(Market mk) {
     log::error("Bithumb time is not synchronized with us (Bithumb: {}, us: [{} - {}])", bithumbTimestamp, t1Ms, t2Ms);
   }
 
-  return MonetaryAmount(last24hVol, mk.base());
+  return {last24hVol, mk.base()};
 }
 
 namespace {

src/api/exchanges/src/huobiprivateapi.cpp

@@ -425,7 +425,7 @@ InitiatedWithdrawInfo HuobiPrivate::launchWithdraw(MonetaryAmount grossAmount, W
   json result = PrivateQuery(_curlHandle, _apiKey, HttpRequestType::kPost, "/v1/dw/withdraw/api/create",
                              std::move(withdrawPostData));
   string withdrawIdStr = ToString(result["data"].get<int64_t>());
-  return InitiatedWithdrawInfo(std::move(destinationWallet), std::move(withdrawIdStr), grossAmount);
+  return {std::move(destinationWallet), std::move(withdrawIdStr), grossAmount};
 }
 
 SentWithdrawInfo HuobiPrivate::isWithdrawSuccessfullySent(const InitiatedWithdrawInfo& initiatedWithdrawInfo) {
@@ -481,7 +481,7 @@ SentWithdrawInfo HuobiPrivate::isWithdrawSuccessfullySent(const InitiatedWithdra
       break;
     }
   }
-  return SentWithdrawInfo(netEmittedAmount, fee, isWithdrawSent);
+  return {netEmittedAmount, fee, isWithdrawSent};
 }
 
 int HuobiPrivate::AccountIdFunc::operator()() {

src/api/exchanges/src/huobipublicapi.cpp

@@ -265,7 +265,7 @@ MonetaryAmount HuobiPublic::queryWithdrawalFee(CurrencyCode currencyCode) {
     for (const json& chainDetail : curDetail["chains"]) {
       std::string_view chainName = chainDetail["chain"].get<std::string_view>();
       if (chainName == cur) {
-        return MonetaryAmount(chainDetail["transactFeeWithdraw"].get<std::string_view>(), cur);
+        return {chainDetail["transactFeeWithdraw"].get<std::string_view>(), cur};
       }
     }
   }

src/api/exchanges/src/krakenprivateapi.cpp

@@ -515,8 +515,7 @@ InitiatedWithdrawInfo KrakenPrivate::launchWithdraw(MonetaryAmount grossAmount,
   }
 
   // {"refid":"BSH3QF5-TDIYVJ-X6U74X"}
-  return InitiatedWithdrawInfo(std::move(destinationWallet), std::move(withdrawData["refid"].get_ref<string&>()),
-                               grossAmount);
+  return {std::move(destinationWallet), std::move(withdrawData["refid"].get_ref<string&>()), grossAmount};
 }
 
 SentWithdrawInfo KrakenPrivate::isWithdrawSuccessfullySent(const InitiatedWithdrawInfo& initiatedWithdrawInfo) {
@@ -531,7 +530,7 @@ SentWithdrawInfo KrakenPrivate::isWithdrawSuccessfullySent(const InitiatedWithdr
       log::info("{} withdraw status: {}", exchangeName(), status);
       MonetaryAmount netWithdrawAmount(trx["amount"].get<std::string_view>(), currencyCode);
       MonetaryAmount fee(trx["fee"].get<std::string_view>(), currencyCode);
-      return SentWithdrawInfo(netWithdrawAmount, fee, status == "Success");
+      return {netWithdrawAmount, fee, status == "Success"};
     }
   }
   throw exception("Kraken: unable to find withdrawal confirmation of {}", initiatedWithdrawInfo.grossEmittedAmount());

src/api/exchanges/src/krakenpublicapi.cpp

@@ -65,7 +65,7 @@ bool CheckCurrencyExchange(std::string_view krakenEntryCurrencyCode, std::string
 }
 
 File GetKrakenWithdrawInfoFile(std::string_view dataDir) {
-  return File(dataDir, File::Type::kCache, "krakenwithdrawinfo.json", File::IfError::kNoThrow);
+  return {dataDir, File::Type::kCache, "krakenwithdrawinfo.json", File::IfError::kNoThrow};
 }
 
 }  // namespace
@@ -379,14 +379,15 @@ std::pair<MarketSet, KrakenPublic::MarketsFunc::MarketInfoMap> KrakenPublic::Mar
 }
 
 MarketOrderBookMap KrakenPublic::AllOrderBooksFunc::operator()(int depth) {
-  MarketOrderBookMap ret;
-  string allAssetPairs;
   const CurrencyExchangeFlatSet& krakenCurrencies = _tradableCurrenciesCache.get();
   const auto& [markets, marketInfoMap] = _marketsCache.get();
-  allAssetPairs.reserve(markets.size() * 8);
+
   using KrakenAssetPairToStdMarketMap = std::unordered_map<string, Market>;
   KrakenAssetPairToStdMarketMap krakenAssetPairToStdMarketMap;
   krakenAssetPairToStdMarketMap.reserve(markets.size());
+
+  string allAssetPairs;
+  MarketOrderBookMap ret;
   ret.reserve(markets.size());
   for (Market mk : markets) {
     auto lb = krakenCurrencies.find(mk.base());

src/api/exchanges/src/kucoinprivateapi.cpp

@@ -386,8 +386,7 @@ InitiatedWithdrawInfo KucoinPrivate::launchWithdraw(MonetaryAmount grossAmount,
   }
 
   json result = PrivateQuery(_curlHandle, _apiKey, HttpRequestType::kPost, "/api/v1/withdrawals", std::move(opts));
-  return InitiatedWithdrawInfo(std::move(destinationWallet), std::move(result["withdrawalId"].get_ref<string&>()),
-                               grossAmount);
+  return {std::move(destinationWallet), std::move(result["withdrawalId"].get_ref<string&>()), grossAmount};
 }
 
 SentWithdrawInfo KucoinPrivate::isWithdrawSuccessfullySent(const InitiatedWithdrawInfo& initiatedWithdrawInfo) {
@@ -422,7 +421,7 @@ SentWithdrawInfo KucoinPrivate::isWithdrawSuccessfullySent(const InitiatedWithdr
       break;
     }
   }
-  return SentWithdrawInfo(netEmittedAmount, fee, isWithdrawSent);
+  return {netEmittedAmount, fee, isWithdrawSent};
 }
 
 }  // namespace cct::api

src/api/exchanges/src/kucoinpublicapi.cpp

@@ -170,7 +170,7 @@ MonetaryAmount KucoinPublic::queryWithdrawalFee(CurrencyCode currencyCode) {
   if (it == currencyInfoSet.end()) {
     throw exception("Unable to find withdrawal fee for {}", currencyCode);
   }
-  return MonetaryAmount(it->withdrawalMinFee, it->currencyExchange.standardCode());
+  return {it->withdrawalMinFee, it->currencyExchange.standardCode()};
 }
 
 MarketOrderBookMap KucoinPublic::AllOrderBooksFunc::operator()(int depth) {
@@ -194,7 +194,9 @@ MarketOrderBookMap KucoinPublic::AllOrderBooksFunc::operator()(int depth) {
     const MarketsFunc::MarketInfo& marketInfo = marketInfoMap.find(mk)->second;
 
     // Use avg traded volume by second as ask/bid vol
-    MonetaryAmount askVol = dayVolume / (2 * 24 * 3600);
+    static constexpr MonetaryAmount::AmountType kAskVolPerDay = static_cast<MonetaryAmount::AmountType>(2) * 24 * 3600;
+
+    MonetaryAmount askVol = dayVolume / kAskVolPerDay;
     askVol.round(marketInfo.baseIncrement, MonetaryAmount::RoundType::kNearest);
     if (askVol == 0) {
       askVol = marketInfo.baseIncrement;
@@ -295,7 +297,7 @@ MonetaryAmount KucoinPublic::sanitizeVolume(Market mk, MonetaryAmount vol) {
 
 MonetaryAmount KucoinPublic::TradedVolumeFunc::operator()(Market mk) {
   json result = PublicQuery(_curlHandle, "/api/v1/market/stats", GetSymbolPostData(mk));
-  return MonetaryAmount(result["vol"].get<std::string_view>(), mk.base());
+  return {result["vol"].get<std::string_view>(), mk.base()};
 }
 
 LastTradesVector KucoinPublic::queryLastTrades(Market mk, [[maybe_unused]] int nbTrades) {
@@ -317,6 +319,6 @@ LastTradesVector KucoinPublic::queryLastTrades(Market mk, [[maybe_unused]] int n
 
 MonetaryAmount KucoinPublic::TickerFunc::operator()(Market mk) {
   json result = PublicQuery(_curlHandle, "/api/v1/market/orderbook/level1", GetSymbolPostData(mk));
-  return MonetaryAmount(result["price"].get<std::string_view>(), mk.quote());
+  return {result["price"].get<std::string_view>(), mk.quote()};
 }
 }  // namespace cct::api

src/api/exchanges/src/upbitprivateapi.cpp

@@ -433,7 +433,7 @@ MonetaryAmount UpbitPrivate::WithdrawFeesFunc::operator()(CurrencyCode currencyC
   json result = PrivateQuery(_curlHandle, _apiKey, HttpRequestType::kGet, "/v1/withdraws/chance",
                              {{"currency", currencyCode.str()}});
   std::string_view amountStr = result["currency"]["withdraw_fee"].get<std::string_view>();
-  return MonetaryAmount(amountStr, currencyCode);
+  return {amountStr, currencyCode};
 }
 
 InitiatedWithdrawInfo UpbitPrivate::launchWithdraw(MonetaryAmount grossAmount, Wallet&& destinationWallet) {
@@ -448,7 +448,7 @@ InitiatedWithdrawInfo UpbitPrivate::launchWithdraw(MonetaryAmount grossAmount, W
   }
   json result =
       PrivateQuery(_curlHandle, _apiKey, HttpRequestType::kPost, "/v1/withdraws/coin", std::move(withdrawPostData));
-  return InitiatedWithdrawInfo(std::move(destinationWallet), std::move(result["uuid"].get_ref<string&>()), grossAmount);
+  return {std::move(destinationWallet), std::move(result["uuid"].get_ref<string&>()), grossAmount};
 }
 
 SentWithdrawInfo UpbitPrivate::isWithdrawSuccessfullySent(const InitiatedWithdrawInfo& initiatedWithdrawInfo) {
@@ -472,7 +472,7 @@ SentWithdrawInfo UpbitPrivate::isWithdrawSuccessfullySent(const InitiatedWithdra
     log::error("{} withdraw of {} has been cancelled", _exchangePublic.name(), currencyCode);
   }
   const bool isDone = stateUpperStr == "DONE";
-  return SentWithdrawInfo(netEmittedAmount, fee, isDone || isCanceled);
+  return {netEmittedAmount, fee, isDone || isCanceled};
 }
 
 }  // namespace cct::api

src/api/interface/test/exchangeretrieverbase_test.cpp

@@ -10,13 +10,13 @@ class ExchangeTest {
 
   ExchangeTest(std::string_view name, std::string_view keyName) : _name(name), _keyName(keyName) {}
 
-  std::string_view name() const { return _name; }
-  std::string_view keyName() const { return _keyName; }
+  [[nodiscard]] std::string_view name() const { return _name; }
+  [[nodiscard]] std::string_view keyName() const { return _keyName; }
 
   ExchangePublic &apiPublic() { return *this; }
-  const ExchangePublic &apiPublic() const { return *this; }
+  [[nodiscard]] const ExchangePublic &apiPublic() const { return *this; }
 
-  bool matches(const ExchangeName &exchangeName) const {
+  [[nodiscard]] bool matches(const ExchangeName &exchangeName) const {
     return exchangeName.name() == _name && (!exchangeName.isKeyNameDefined() || exchangeName.keyName() == _keyName);
   }
 

src/engine/src/coincentercommand.cpp

@@ -5,7 +5,7 @@
 namespace cct {
 bool CoincenterCommand::isPublic() const {
   switch (_type) {
-    case CoincenterCommandType::kHealthCheck:
+    case CoincenterCommandType::kHealthCheck:  // NOLINT(bugprone-branch-clone)
       [[fallthrough]];
     case CoincenterCommandType::kMarkets:
       [[fallthrough]];
@@ -33,7 +33,7 @@ bool CoincenterCommand::isReadOnly() const {
     return true;
   }
   switch (_type) {
-    case CoincenterCommandType::kBalance:
+    case CoincenterCommandType::kBalance:  // NOLINT(bugprone-branch-clone)
       [[fallthrough]];
     case CoincenterCommandType::kDepositInfo:
       [[fallthrough]];

src/engine/src/coincentercommands.cpp

@@ -31,9 +31,9 @@ CoincenterCmdLineOptions CoincenterCommands::ParseOptions(int argc, const char *
 
 MonitoringInfo CoincenterCommands::CreateMonitoringInfo(std::string_view programName,
                                                         const CoincenterCmdLineOptions &cmdLineOptions) {
-  return MonitoringInfo(cmdLineOptions.useMonitoring, programName, cmdLineOptions.monitoringAddress,
-                        cmdLineOptions.monitoringPort, cmdLineOptions.monitoringUsername,
-                        cmdLineOptions.monitoringPassword);
+  return {cmdLineOptions.useMonitoring,      programName,
+          cmdLineOptions.monitoringAddress,  cmdLineOptions.monitoringPort,
+          cmdLineOptions.monitoringUsername, cmdLineOptions.monitoringPassword};
 }
 
 namespace {

src/engine/src/exchangesorchestrator.cpp

@@ -416,9 +416,8 @@ TradedAmountsPerExchange ExchangesOrchestrator::trade(MonetaryAmount startAmount
   if (privateExchangeNames.size() == 1 && !isPercentageTrade) {
     // In this special case we don't need to call the balance - call trade directly
     Exchange &exchange = _exchangeRetriever.retrieveUniqueCandidate(privateExchangeNames.front());
-    return TradedAmountsPerExchange(
-        1,
-        std::make_pair(std::addressof(exchange), exchange.apiPrivate().trade(startAmount, toCurrency, tradeOptions)));
+    return {1, std::make_pair(std::addressof(exchange),
+                              exchange.apiPrivate().trade(startAmount, toCurrency, tradeOptions))};
   }
 
   const CurrencyCode fromCurrency = startAmount.currencyCode();

src/engine/src/stringoptionparser.cpp

@@ -23,9 +23,7 @@ ExchangeNames GetExchanges(std::string_view str) {
   return exchanges;
 }
 
-std::string_view StrEnd(std::string_view opt, std::size_t startPos) {
-  return std::string_view(opt.begin() + startPos, opt.end());
-}
+std::string_view StrEnd(std::string_view opt, std::size_t startPos) { return {opt.begin() + startPos, opt.end()}; }
 
 bool IsExchangeName(std::string_view str) {
   string lowerStr = ToLower(str);
@@ -51,7 +49,7 @@ std::string_view GetNextStr(std::string_view opt, CharOrStringType sep, std::siz
   while (endPos > 0U && isblank(opt[endPos - 1U])) {
     --endPos;
   }
-  return std::string_view(opt.begin() + begPos, opt.begin() + endPos);
+  return {opt.begin() + begPos, opt.begin() + endPos};
 }
 
 auto GetNextPercentageAmount(std::string_view opt, std::string_view sepWithPercentageAtLast, std::size_t &pos) {
@@ -114,7 +112,7 @@ StringOptionParser::CurrencyPrivateExchanges StringOptionParser::getCurrencyPriv
     throw invalid_argument("Expected a currency code first");
   }
 
-  return CurrencyPrivateExchanges(CurrencyCode(curStr), GetExchanges(exchangesStr));
+  return {CurrencyCode(curStr), GetExchanges(exchangesStr)};
 }
 
 StringOptionParser::CurrenciesPrivateExchanges StringOptionParser::getCurrenciesPrivateExchanges(