Align clang-format rules with project style

Author: islero

.clang-format

@@ -7,10 +7,12 @@ UseTab: Never
 AccessModifierOffset: -4
 ContinuationIndentWidth: 4
 ConstructorInitializerIndentWidth: 4
-ColumnLimit: 0
+ColumnLimit: 120
 PointerAlignment: Left
 ReferenceAlignment: Left
 SortIncludes: false
+IndentCaseLabels: true
+AlignTrailingComments: Never
 AllowShortBlocksOnASingleLine: Empty
 AllowShortCaseLabelsOnASingleLine: true
 AllowShortFunctionsOnASingleLine: All

benchmarks/bench_latency.cpp

@@ -67,7 +67,7 @@ static void BM_LatencyHistogram_Record(benchmark::State& state) {
     DefaultLatencyHistogram histogram;
 
     for (auto _ : state) {
-        histogram.record(1000);  // 1 microsecond
+        histogram.record(1000); // 1 microsecond
     }
     state.SetItemsProcessed(state.iterations());
 }

benchmarks/bench_orderbook.cpp

@@ -133,8 +133,7 @@ static void BM_OrderBook_DeepBook_Add(benchmark::State& state) {
 
         // Add orders across multiple price levels
         for (int64_t i = 0; i < numLevels; ++i) {
-            (void)book.addOrder(orderId++, Side::Buy,
-                         priceFromDouble(50000.0 - static_cast<double>(i)), 100);
+            (void)book.addOrder(orderId++, Side::Buy, priceFromDouble(50000.0 - static_cast<double>(i)), 100);
         }
     }
 

benchmarks/bench_spsc_queue.cpp

@@ -29,7 +29,7 @@ static void BM_SPSCQueue_PushPop_SingleThread(benchmark::State& state) {
         benchmark::DoNotOptimize(value);
     }
 
-    state.SetItemsProcessed(state.iterations() * 2);  // 2 ops per iteration
+    state.SetItemsProcessed(state.iterations() * 2); // 2 ops per iteration
 }
 BENCHMARK(BM_SPSCQueue_PushPop_SingleThread);
 
@@ -156,7 +156,7 @@ static void BM_SPSCQueue_ElementSize(benchmark::State& state) {
     state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * 2 * static_cast<int64_t>(ElementSize));
 }
 BENCHMARK_TEMPLATE(BM_SPSCQueue_ElementSize, 8);
-BENCHMARK_TEMPLATE(BM_SPSCQueue_ElementSize, 64);   // Cache line
+BENCHMARK_TEMPLATE(BM_SPSCQueue_ElementSize, 64); // Cache line
 BENCHMARK_TEMPLATE(BM_SPSCQueue_ElementSize, 128);
 BENCHMARK_TEMPLATE(BM_SPSCQueue_ElementSize, 256);
 
@@ -224,7 +224,7 @@ BENCHMARK(BM_SPSCQueue_FrontPeek);
 // Empty check benchmark
 static void BM_SPSCQueue_EmptyCheck(benchmark::State& state) {
     SPSCQueue<int, 1024> queue;
-    (void)queue.tryPush(42);  // Not empty
+    (void)queue.tryPush(42); // Not empty
 
     for (auto _ : state) {
         bool empty = queue.empty();

include/core/SPSCQueue.hpp

@@ -228,7 +228,7 @@ class alignas(CACHE_LINE_SIZE) SPSCQueue {
      * @return Maximum number of elements (Capacity - 1 usable).
      */
     [[nodiscard]] static constexpr std::size_t capacity() noexcept {
-        return Capacity - 1;  // One slot always empty to distinguish full/empty
+        return Capacity - 1; // One slot always empty to distinguish full/empty
     }
 
     /**
@@ -323,7 +323,7 @@ class SPSCQueueBlocking : public SPSCQueue<T, Capacity> {
     static void spinWait(std::size_t& spins) noexcept {
         if (++spins < MaxSpins) {
 #if defined(__x86_64__) || defined(_M_X64)
-            _mm_pause();  // CPU hint for spin-wait
+            _mm_pause(); // CPU hint for spin-wait
 #elif defined(__aarch64__)
             asm volatile("yield");
 #endif

include/core/Timestamp.hpp

@@ -208,7 +208,7 @@ class TscCalibrator {
         m_nanosPerCycle = 1.0 / m_cyclesPerNano;
     }
 
-    double m_cyclesPerNano{3.0};  // Default ~3GHz
+    double m_cyclesPerNano{3.0}; // Default ~3GHz
     double m_nanosPerCycle{0.333};
 };
 

include/core/Types.hpp

@@ -124,8 +124,8 @@ enum class Side : std::uint8_t {
 enum class OrderType : std::uint8_t {
     Limit  = 0,
     Market = 1,
-    IOC    = 2,  // Immediate or Cancel
-    FOK    = 3   // Fill or Kill
+    IOC    = 2, // Immediate or Cancel
+    FOK    = 3 // Fill or Kill
 };
 
 /**

include/gateway/OrderEntryGateway.hpp

@@ -57,13 +57,13 @@ struct GatewayConfig {
     std::size_t maxOpenOrders{1000};
 
     /// Order timeout in nanoseconds
-    Timestamp orderTimeoutNanos{5'000'000'000};  // 5 seconds
+    Timestamp orderTimeoutNanos{5'000'000'000}; // 5 seconds
 
     /// Enable pre-trade risk checks
     bool enableRiskChecks{true};
 
     /// Maximum order value (price * quantity)
-    std::int64_t maxOrderValue{1'000'000'000'000};  // $10,000 at 8 decimals
+    std::int64_t maxOrderValue{1'000'000'000'000}; // $10,000 at 8 decimals
 
     /// Maximum position per symbol
     Quantity maxPositionPerSymbol{100'000};
@@ -83,20 +83,20 @@ struct GatewayConfig {
  * @brief Internal order representation with full state tracking.
  */
 struct alignas(CACHE_LINE_SIZE) InternalOrder {
-    OrderId     clientOrderId;    ///< Client-assigned order ID
-    OrderId     exchangeOrderId;  ///< Exchange-assigned order ID
-    SymbolId    symbolId;         ///< Instrument
-    std::string symbol;           ///< Symbol string
-    Side        side;             ///< Buy/Sell
-    Price       price;            ///< Limit price
-    Quantity    orderQty;         ///< Original quantity
-    Quantity    filledQty;        ///< Cumulative filled quantity
-    Quantity    remainingQty;     ///< Remaining quantity
-    OrderStatus status;           ///< Current status
-    OrderType   orderType;        ///< Order type
-    Timestamp   submitTime;       ///< When order was submitted
-    Timestamp   lastUpdateTime;   ///< Last status change
-    std::uint64_t strategyId;     ///< Originating strategy
+    OrderId     clientOrderId; ///< Client-assigned order ID
+    OrderId     exchangeOrderId; ///< Exchange-assigned order ID
+    SymbolId    symbolId; ///< Instrument
+    std::string symbol; ///< Symbol string
+    Side        side; ///< Buy/Sell
+    Price       price; ///< Limit price
+    Quantity    orderQty; ///< Original quantity
+    Quantity    filledQty; ///< Cumulative filled quantity
+    Quantity    remainingQty; ///< Remaining quantity
+    OrderStatus status; ///< Current status
+    OrderType   orderType; ///< Order type
+    Timestamp   submitTime; ///< When order was submitted
+    Timestamp   lastUpdateTime; ///< Last status change
+    std::uint64_t strategyId; ///< Originating strategy
 
     InternalOrder() noexcept = default;
 
@@ -125,13 +125,13 @@ struct ExecutionReport {
     OrderId     clientOrderId;
     OrderId     exchangeOrderId;
     OrderStatus status;
-    Price       lastPrice;        ///< Last fill price
-    Quantity    lastQty;          ///< Last fill quantity
-    Quantity    cumulativeQty;    ///< Total filled quantity
-    Quantity    leavesQty;        ///< Remaining quantity
-    Timestamp   transactTime;     ///< Exchange timestamp
-    int         rejectReason;     ///< Reason code if rejected
-    std::string text;             ///< Reject reason text
+    Price       lastPrice; ///< Last fill price
+    Quantity    lastQty; ///< Last fill quantity
+    Quantity    cumulativeQty; ///< Total filled quantity
+    Quantity    leavesQty; ///< Remaining quantity
+    Timestamp   transactTime; ///< Exchange timestamp
+    int         rejectReason; ///< Reason code if rejected
+    std::string text; ///< Reject reason text
 };
 
 //==============================================================================
@@ -650,7 +650,7 @@ class OrderEntryGateway {
 
 private:
     [[nodiscard]] bool checkRateLimit(Timestamp now) noexcept {
-        constexpr Timestamp WINDOW_NANOS = 1'000'000'000;  // 1 second
+        constexpr Timestamp WINDOW_NANOS = 1'000'000'000; // 1 second
 
         while (m_orderTimeCount > 0 &&
                (now - m_orderTimes[m_orderTimeHead]) > WINDOW_NANOS) {

include/market_data/MarketDataHandler.hpp

@@ -72,15 +72,15 @@ struct MarketDataConfig {
  * the wire protocol (FIX, binary, etc.).
  */
 struct alignas(CACHE_LINE_SIZE) MarketDataMessage {
-    SymbolId   symbolId;          ///< Instrument symbol
-    SeqNum     seqNum;            ///< Exchange sequence number
-    Timestamp  sendingTime;       ///< Exchange timestamp (SendingTime)
-    Timestamp  receiveTime;       ///< Local receive timestamp
-    MdMsgType  msgType;           ///< Message type
-    Side       side;              ///< Bid/Ask for book updates
-    Price      price;             ///< Price
-    Quantity   quantity;          ///< Quantity
-    OrderId    orderId;           ///< Order ID (for order-level books)
+    SymbolId   symbolId; ///< Instrument symbol
+    SeqNum     seqNum; ///< Exchange sequence number
+    Timestamp  sendingTime; ///< Exchange timestamp (SendingTime)
+    Timestamp  receiveTime; ///< Local receive timestamp
+    MdMsgType  msgType; ///< Message type
+    Side       side; ///< Bid/Ask for book updates
+    Price      price; ///< Price
+    Quantity   quantity; ///< Quantity
+    OrderId    orderId; ///< Order ID (for order-level books)
 
     MarketDataMessage() noexcept = default;
 
@@ -407,7 +407,7 @@ class MarketDataHandler {
         MarketDataMessage msg;
         msg.symbolId = symbolId;
         msg.receiveTime = entry.receiveTime;
-        msg.sendingTime = entry.receiveTime;  // Use receive time as proxy
+        msg.sendingTime = entry.receiveTime; // Use receive time as proxy
         msg.price = entry.price;
         msg.quantity = entry.size;
 

include/market_data/QuickFixApplication.hpp

@@ -85,12 +85,12 @@ inline constexpr char EXEC_TYPE_REJECTED        = '8';
  * @brief Normalized market data entry extracted from QuickFIX message.
  */
 struct QuickFixMdEntry {
-    char       entryType;      ///< '0'=Bid, '1'=Ask, '2'=Trade
-    char       updateAction;   ///< '0'=New, '1'=Change, '2'=Delete
-    Price      price;          ///< Price
-    Quantity   size;           ///< Size
-    std::string entryId;       ///< Entry ID (if provided)
-    Timestamp  receiveTime;    ///< Local receive timestamp
+    char       entryType; ///< '0'=Bid, '1'=Ask, '2'=Trade
+    char       updateAction; ///< '0'=New, '1'=Change, '2'=Delete
+    Price      price; ///< Price
+    Quantity   size; ///< Size
+    std::string entryId; ///< Entry ID (if provided)
+    Timestamp  receiveTime; ///< Local receive timestamp
 };
 
 //==============================================================================
@@ -101,16 +101,16 @@ struct QuickFixMdEntry {
  * @brief Normalized execution report extracted from QuickFIX message.
  */
 struct QuickFixExecReport {
-    OrderId     clOrdId;           ///< Client order ID
-    OrderId     orderId;           ///< Exchange order ID
-    char        execType;          ///< Execution type
-    OrderStatus status;            ///< Order status
-    Price       lastPx;            ///< Last fill price
-    Quantity    lastQty;           ///< Last fill quantity
-    Quantity    cumQty;            ///< Cumulative filled quantity
-    Quantity    leavesQty;         ///< Remaining quantity
-    std::string text;              ///< Reject reason text
-    Timestamp   receiveTime;       ///< Local receive timestamp
+    OrderId     clOrdId; ///< Client order ID
+    OrderId     orderId; ///< Exchange order ID
+    char        execType; ///< Execution type
+    OrderStatus status; ///< Order status
+    Price       lastPx; ///< Last fill price
+    Quantity    lastQty; ///< Last fill quantity
+    Quantity    cumQty; ///< Cumulative filled quantity
+    Quantity    leavesQty; ///< Remaining quantity
+    std::string text; ///< Reject reason text
+    Timestamp   receiveTime; ///< Local receive timestamp
 };
 
 //==============================================================================
@@ -332,7 +332,7 @@ class QuickFixApplication : public FIX::Application, public FIX::MessageCracker
 
         request.set(FIX::MDReqID(mdReqId));
         request.set(FIX::SubscriptionRequestType(subscriptionType));
-        request.set(FIX::MarketDepth(0));  // Full book
+        request.set(FIX::MarketDepth(0)); // Full book
 
         // Add MD entry types
         FIX44::MarketDataRequest::NoMDEntryTypes entryTypesGroup;
@@ -436,7 +436,7 @@ class QuickFixApplication : public FIX::Application, public FIX::MessageCracker
 
             QuickFixMdEntry entry;
             entry.receiveTime = receiveTime;
-            entry.updateAction = qfix::MD_ACTION_NEW;  // Snapshot implies new
+            entry.updateAction = qfix::MD_ACTION_NEW; // Snapshot implies new
 
             FIX::MDEntryType entryType;
             group.get(entryType);
@@ -590,14 +590,14 @@ class QuickFixApplication : public FIX::Application, public FIX::MessageCracker
         if (m_mdCallback) {
             m_mdCallback(entry);
         }
-        m_mdQueue.tryPush(entry);  // Best effort
+        m_mdQueue.tryPush(entry); // Best effort
     }
 
     void enqueueExecutionReport(const QuickFixExecReport& report) {
         if (m_execCallback) {
             m_execCallback(report);
         }
-        m_execQueue.tryPush(report);  // Best effort
+        m_execQueue.tryPush(report); // Best effort
     }
 
     bool sendMessage(FIX::Message& message) {