31 feat tidy up the code refactoring code smells and more

include/strategies/randomStrategy.hpp

@@ -57,8 +57,7 @@ class RandomStrategy : public IStrategy {
     // is passed by mutable reference so future strategies (trailing
     // stops, partial closes, scale-ins) can act on open positions
     // here without changing the interface.
-    void during(std::size_t tickValue,
-                const PriceData& price,
+    void during(const PriceData& price,
                 TradeManager& tradeManager) override;
 
 private:

include/strategies/strategy.hpp

@@ -56,7 +56,6 @@ class IStrategy {
     // analogue is just passing the manager as a parameter; C# has no
     // distinction between reference and pointer so the by-ref nature
     // is implicit there.
-    virtual void during(std::size_t tickValue,
-                        const PriceData& price,
+    virtual void during(const PriceData& price,
                         TradeManager& tradeManager) = 0;
 };

include/utilities/base64.hpp

@@ -13,8 +13,8 @@
 
 class Base64 {
 public:
-  static const std::string b64encode(const void* data, const size_t &len);
-  static const std::string b64decode(const void* data, const size_t &len);
+  static const std::string b64encode(const unsigned char* data, const size_t &len);
+  static const std::string b64decode(const unsigned char* data, const size_t &len);
   static std::string b64encode(const std::string& str);
   static std::string b64decode(const std::string& str64);
   static bool isValidBase64(const std::string& input);

source/databaseConnection.cpp

@@ -13,7 +13,13 @@
 #include <boost/decimal.hpp>
 
 static std::chrono::system_clock::time_point fastParseTimestamp(const char* ts) {
-    int year = 0, month = 0, day = 0, hour = 0, min = 0, sec = 0, usec = 0;
+    int year = 0;
+    int month = 0;
+    int day = 0;
+    int hour = 0;
+    int min = 0;
+    int sec = 0;
+    int usec = 0;
     const int parsedFields =
         std::sscanf(ts, "%4d-%2d-%2d %2d:%2d:%2d.%d", &year, &month, &day, &hour, &min, &sec, &usec);
     if (parsedFields != 6 && parsedFields != 7) {
@@ -59,7 +65,8 @@ std::vector<PriceData> DatabaseConnection::streamQuery(const std::string& query)
 
     for (std::size_t i = 0; i < result.size(); ++i) {
         const auto& row = result[static_cast<pqxx::result::size_type>(i)];
-        boost::decimal::decimal64_t ask, bid;
+        boost::decimal::decimal64_t ask;
+        boost::decimal::decimal64_t bid;
         auto symbol = row[0].view();
         auto sv1 = row[1].view();
         auto sv2 = row[2].view();

source/operations.cpp

@@ -64,7 +64,6 @@ void Operations::run(const std::vector<PriceData>& ticks,
 
     const auto& tradingVars = config.STRATEGY.TRADING_VARIABLES;
 
-    std::size_t tickIndex = 0;
     for (const auto& tick : ticks) {
 
         // Close any trade whose stop-loss or take-profit fired on this tick
@@ -90,9 +89,7 @@ void Operations::run(const std::vector<PriceData>& ticks,
         // (e.g. trailing stops, partial closes). The default
         // RandomStrategy implementation is a no-op now that exits are
         // handled by reviewStopAndLimit above.
-        strategy->during(tickIndex, tick, *tradeManager);
-
-        ++tickIndex;
+        strategy->during(tick, *tradeManager);
     }
 
     std::cout << "Final PnL: " << std::fixed << std::setprecision(2) << tradeManager->calculatePnl() << std::endl;

source/strategies/randomStrategy.cpp

@@ -23,8 +23,7 @@ std::optional<Direction> RandomStrategy::decide(const PriceData& /*tick*/) {
     return coin(rng) ? Direction::LONG : Direction::SHORT;
 }
 
-void RandomStrategy::during(std::size_t /*tickValue*/,
-                            const PriceData& /*price*/,
+void RandomStrategy::during(const PriceData& /*price*/,
                             TradeManager& /*tradeManager*/) {
     // Exits are handled centrally by Operations using each trade's
     // stop-loss / take-profit pip distances. Strategies that want

source/trading/tradeManager.cpp

@@ -15,7 +15,7 @@
 namespace {
 std::string nextTradeId() {
     static std::atomic<uint64_t> counter{0};
-    return "T" + std::to_string(counter.fetch_add(1, std::memory_order_relaxed));
+    return "T" + std::to_string(counter.fetch_add(1));
 }
 }
 

source/utilities/base64.cpp

@@ -33,10 +33,10 @@ std::string Base64::checkInput(const std::string& base64_input) {
 }
 
 // Code adapted from Stack Overflow https://stackoverflow.com/a/37109258/20806857
-const std::string Base64::b64encode(const void* data, const size_t &len)
+const std::string Base64::b64encode(const unsigned char* data, const size_t &len)
 {
     std::string result((len + 2) / 3 * 4, '=');
-    unsigned char *p = (unsigned  char*) data;
+    const unsigned char *p = data;
     char *str = &result[0];
     size_t j = 0, pad = len % 3;
     const size_t last = len - pad;
@@ -59,11 +59,11 @@ const std::string Base64::b64encode(const void* data, const size_t &len)
     return result;
 }
 
-const std::string Base64::b64decode(const void* data, const size_t &len)
+const std::string Base64::b64decode(const unsigned char* data, const size_t &len)
 {
     if (len == 0) return "";
 
-    unsigned char *p = (unsigned char*) data;
+    const unsigned char *p = data;
     size_t j = 0,
         pad1 = len % 4 || p[len - 1] == '=',
         pad2 = pad1 && (len % 4 > 2 || p[len - 2] != '=');
@@ -93,12 +93,12 @@ const std::string Base64::b64decode(const void* data, const size_t &len)
 
 std::string Base64::b64encode(const std::string& str)
 {
-    return b64encode(str.c_str(), str.size());
+    return b64encode(reinterpret_cast<const unsigned char*>(str.c_str()), str.size());
 }
 
 std::string Base64::b64decode(const std::string& str64)
 {
-    return b64decode(str64.c_str(), str64.size());
+    return b64decode(reinterpret_cast<const unsigned char*>(str64.c_str()), str64.size());
 }
 
 bool Base64::isValidBase64(const std::string& input) {