strategy: add order tracking and position queries (#60)

Author: eeiaao

docs/components/strategy/strategy.md

@@ -92,15 +92,43 @@ protected:
 
 ## Signal Emission
 
+All order methods return an `OrderId` for tracking:
+
 ```cpp
 protected:
   void emit(const Signal& signal);
-  void emitMarketBuy(SymbolId symbol, Quantity qty);
-  void emitMarketSell(SymbolId symbol, Quantity qty);
-  void emitLimitBuy(SymbolId symbol, Price price, Quantity qty);
-  void emitLimitSell(SymbolId symbol, Price price, Quantity qty);
+
+  // Returns OrderId for tracking
+  OrderId emitMarketBuy(SymbolId symbol, Quantity qty);
+  OrderId emitMarketSell(SymbolId symbol, Quantity qty);
+  OrderId emitLimitBuy(SymbolId symbol, Price price, Quantity qty);
+  OrderId emitLimitSell(SymbolId symbol, Price price, Quantity qty);
+
   void emitCancel(OrderId orderId);
   void emitCancelAll(SymbolId symbol);
+  void emitModify(OrderId orderId, Price newPrice, Quantity newQty);
+```
+
+## Order and Position Tracking
+
+Query order status and positions (requires `setOrderTracker` / `setPositionManager`):
+
+```cpp
+protected:
+  // Position queries
+  Quantity position(SymbolId sym) const;  // Net position for symbol
+  Quantity position() const;              // Primary symbol position
+
+  // Order status queries
+  std::optional<OrderEventStatus> getOrderStatus(OrderId orderId) const;
+  std::optional<OrderState> getOrder(OrderId orderId) const;
+```
+
+Connect trackers:
+
+```cpp
+strategy.setOrderTracker(&orderTracker);
+strategy.setPositionManager(&positionTracker);
 ```
 
 ## Cross-Symbol Helpers
@@ -139,15 +167,28 @@ protected:
     auto ask = c.book.bestAsk();
     if (!bid || !ask) return;
 
-    // Check position
-    if (c.isFlat() && shouldBuy(ev.trade.price))
+    // Check position via tracker
+    if (position().isZero() && shouldBuy(ev.trade.price))
     {
-      emitMarketBuy(c.symbolId, Quantity::fromDouble(1.0));
+      // Returns OrderId for tracking
+      OrderId id = emitMarketBuy(c.symbolId, Quantity::fromDouble(1.0));
+      _pendingOrder = id;
+    }
+
+    // Check order status
+    if (_pendingOrder)
+    {
+      auto status = getOrderStatus(*_pendingOrder);
+      if (status && *status == OrderEventStatus::FILLED)
+      {
+        _pendingOrder = std::nullopt;
+      }
     }
   }
 
 private:
   bool _running{false};
+  std::optional<OrderId> _pendingOrder;
 };
 ```
 

include/flox/log/atomic_logger.h

@@ -48,6 +48,8 @@ class AtomicLogger final : public ILogger
   void warn(std::string_view msg) override;
   void error(std::string_view msg) override;
 
+  void flush();
+
  private:
   static constexpr size_t BUFFER_SIZE = 1024;
   static constexpr size_t MAX_MESSAGE_SIZE = 256;

include/flox/strategy/signal.h

@@ -19,7 +19,8 @@ enum class SignalType : uint8_t
   Market,
   Limit,
   Cancel,
-  CancelAll
+  CancelAll,
+  Modify
 };
 
 struct Signal
@@ -29,36 +30,43 @@ struct Signal
   Side side{};
   Price price{};
   Quantity quantity{};
-  OrderId orderId{};  // for Cancel
+  OrderId orderId{};
+  Price newPrice{};        // for Modify
+  Quantity newQuantity{};  // for Modify
 
-  static Signal marketBuy(SymbolId sym, Quantity qty)
+  static Signal marketBuy(SymbolId sym, Quantity qty, OrderId id)
   {
-    return Signal{SignalType::Market, sym, Side::BUY, Price{}, qty, 0};
+    return Signal{SignalType::Market, sym, Side::BUY, Price{}, qty, id, Price{}, Quantity{}};
   }
 
-  static Signal marketSell(SymbolId sym, Quantity qty)
+  static Signal marketSell(SymbolId sym, Quantity qty, OrderId id)
   {
-    return Signal{SignalType::Market, sym, Side::SELL, Price{}, qty, 0};
+    return Signal{SignalType::Market, sym, Side::SELL, Price{}, qty, id, Price{}, Quantity{}};
   }
 
-  static Signal limitBuy(SymbolId sym, Price px, Quantity qty)
+  static Signal limitBuy(SymbolId sym, Price px, Quantity qty, OrderId id)
   {
-    return Signal{SignalType::Limit, sym, Side::BUY, px, qty, 0};
+    return Signal{SignalType::Limit, sym, Side::BUY, px, qty, id, Price{}, Quantity{}};
   }
 
-  static Signal limitSell(SymbolId sym, Price px, Quantity qty)
+  static Signal limitSell(SymbolId sym, Price px, Quantity qty, OrderId id)
   {
-    return Signal{SignalType::Limit, sym, Side::SELL, px, qty, 0};
+    return Signal{SignalType::Limit, sym, Side::SELL, px, qty, id, Price{}, Quantity{}};
   }
 
   static Signal cancel(OrderId id)
   {
-    return Signal{SignalType::Cancel, 0, Side::BUY, Price{}, Quantity{}, id};
+    return Signal{SignalType::Cancel, 0, Side::BUY, Price{}, Quantity{}, id, Price{}, Quantity{}};
   }
 
   static Signal cancelAll(SymbolId sym)
   {
-    return Signal{SignalType::CancelAll, sym, Side::BUY, Price{}, Quantity{}, 0};
+    return Signal{SignalType::CancelAll, sym, Side::BUY, Price{}, Quantity{}, 0, Price{}, Quantity{}};
+  }
+
+  static Signal modify(OrderId id, Price newPx, Quantity newQty)
+  {
+    return Signal{SignalType::Modify, 0, Side::BUY, Price{}, Quantity{}, id, newPx, newQty};
   }
 };
 

include/flox/strategy/strategy.h

@@ -12,12 +12,16 @@
 #include "flox/book/events/book_update_event.h"
 #include "flox/book/events/trade_event.h"
 #include "flox/engine/symbol_registry.h"
+#include "flox/execution/order_tracker.h"
+#include "flox/position/abstract_position_manager.h"
 #include "flox/strategy/abstract_signal_handler.h"
 #include "flox/strategy/abstract_strategy.h"
 #include "flox/strategy/signal.h"
 #include "flox/strategy/symbol_context.h"
 #include "flox/strategy/symbol_state_map.h"
 
+#include <atomic>
+#include <optional>
 #include <set>
 #include <stdexcept>
 #include <vector>
@@ -52,6 +56,8 @@ class Strategy : public IStrategy
   SubscriberId id() const override { return _id; }
 
   void setSignalHandler(ISignalHandler* handler) noexcept { _signalHandler = handler; }
+  void setOrderTracker(OrderTracker* tracker) noexcept { _orderTracker = tracker; }
+  void setPositionManager(IPositionManager* pm) noexcept { _positionManager = pm; }
 
   void onTrade(const TradeEvent& ev) final
   {
@@ -99,6 +105,25 @@ class Strategy : public IStrategy
 
   const std::vector<SymbolId>& symbols() const noexcept { return _symbols; }
 
+  // Position and order status queries
+  Quantity position(SymbolId sym) const
+  {
+    return _positionManager ? _positionManager->getPosition(sym) : Quantity{};
+  }
+
+  Quantity position() const { return position(_symbols[0]); }
+
+  std::optional<OrderEventStatus> getOrderStatus(OrderId orderId) const
+  {
+    return _orderTracker ? _orderTracker->getStatus(orderId) : std::nullopt;
+  }
+
+  std::optional<OrderState> getOrder(OrderId orderId) const
+  {
+    return _orderTracker ? _orderTracker->get(orderId) : std::nullopt;
+  }
+
+  // Signal emission
   void emit(const Signal& signal)
   {
     if (_signalHandler)
@@ -107,22 +132,53 @@ class Strategy : public IStrategy
     }
   }
 
-  void emitMarketBuy(SymbolId symbol, Quantity qty) { emit(Signal::marketBuy(symbol, qty)); }
-  void emitMarketSell(SymbolId symbol, Quantity qty) { emit(Signal::marketSell(symbol, qty)); }
-  void emitLimitBuy(SymbolId symbol, Price price, Quantity qty)
+  OrderId emitMarketBuy(SymbolId symbol, Quantity qty)
+  {
+    OrderId id = nextOrderId();
+    emit(Signal::marketBuy(symbol, qty, id));
+    return id;
+  }
+
+  OrderId emitMarketSell(SymbolId symbol, Quantity qty)
+  {
+    OrderId id = nextOrderId();
+    emit(Signal::marketSell(symbol, qty, id));
+    return id;
+  }
+
+  OrderId emitLimitBuy(SymbolId symbol, Price price, Quantity qty)
   {
-    emit(Signal::limitBuy(symbol, price, qty));
+    OrderId id = nextOrderId();
+    emit(Signal::limitBuy(symbol, price, qty, id));
+    return id;
   }
-  void emitLimitSell(SymbolId symbol, Price price, Quantity qty)
+
+  OrderId emitLimitSell(SymbolId symbol, Price price, Quantity qty)
   {
-    emit(Signal::limitSell(symbol, price, qty));
+    OrderId id = nextOrderId();
+    emit(Signal::limitSell(symbol, price, qty, id));
+    return id;
   }
+
   void emitCancel(OrderId orderId) { emit(Signal::cancel(orderId)); }
   void emitCancelAll(SymbolId symbol) { emit(Signal::cancelAll(symbol)); }
 
+  void emitModify(OrderId orderId, Price newPrice, Quantity newQty)
+  {
+    emit(Signal::modify(orderId, newPrice, newQty));
+  }
+
  private:
+  OrderId nextOrderId() noexcept
+  {
+    static std::atomic<OrderId> s_globalOrderId{1};
+    return s_globalOrderId++;
+  }
+
   SubscriberId _id;
   ISignalHandler* _signalHandler{nullptr};
+  OrderTracker* _orderTracker{nullptr};
+  IPositionManager* _positionManager{nullptr};
   std::vector<SymbolId> _symbols;
   std::set<SymbolId> _symbolSet;
   mutable SymbolStateMap<SymbolContext> _contexts;

src/backtest/backtest_runner.cpp

@@ -142,12 +142,21 @@ void BacktestRunner::onSignal(const Signal& signal)
     case SignalType::CancelAll:
       _executor.cancelAllOrders(signal.symbol);
       break;
+    case SignalType::Modify:
+    {
+      Order newOrder{.id = _nextOrderId++,
+                     .price = signal.newPrice,
+                     .quantity = signal.newQuantity};
+      _executor.replaceOrder(signal.orderId, newOrder);
+      break;
+    }
   }
 }
 
 Order BacktestRunner::signalToOrder(const Signal& sig)
 {
-  return Order{.id = _nextOrderId++,
+  OrderId id = (sig.orderId != 0) ? sig.orderId : _nextOrderId++;
+  return Order{.id = id,
                .side = sig.side,
                .price = sig.price,
                .quantity = sig.quantity,

src/log/atomic_logger.cpp

@@ -46,6 +46,19 @@ void AtomicLogger::info(std::string_view msg) { log(LogLevel::Info, msg); }
 void AtomicLogger::warn(std::string_view msg) { log(LogLevel::Warn, msg); }
 void AtomicLogger::error(std::string_view msg) { log(LogLevel::Error, msg); }
 
+void AtomicLogger::flush()
+{
+  _cv.notify_one();
+  while (_readIndex.load(std::memory_order_acquire) < _writeIndex.load(std::memory_order_acquire))
+  {
+    std::this_thread::yield();
+  }
+  if (_file)
+  {
+    std::fflush(_file);
+  }
+}
+
 void AtomicLogger::log(LogLevel level, std::string_view msg)
 {
   if (level < _opts.levelThreshold)
@@ -86,17 +99,17 @@ void AtomicLogger::flushLoop()
       _cv.wait_for(lock, std::chrono::milliseconds(1));
     }
 
-    rotateIfNeeded();
-
     while (_readIndex.load(std::memory_order_acquire) < _writeIndex.load(std::memory_order_acquire))
     {
+      rotateIfNeeded();
       const size_t idx = _readIndex.fetch_add(1, std::memory_order_acq_rel) % BUFFER_SIZE;
       writeToOutput(_buffer[idx]);
     }
   }
 
   while (_readIndex.load() < _writeIndex.load())
   {
+    rotateIfNeeded();
     const size_t idx = _readIndex.fetch_add(1) % BUFFER_SIZE;
     writeToOutput(_buffer[idx]);
   }