events.hpp

Go to the documentation of this file.

// Copyright 2026 Slick Quant
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <slick/orderbook/config.hpp>
#include <slick/orderbook/types.hpp>
#include <array>
 
SLICK_NAMESPACE_BEGIN
 
enum ChangeFlag : uint8_t {
    PriceChanged = 0x01,    // Price level was added/moved
    QuantityChanged = 0x02, // Quantity at level changed
    LastInBatch = 0x04,     // Last update in external batch
};
 
struct PriceLevelUpdate {
    Timestamp timestamp;    // Update timestamp
    uint64_t seq_num;       // Exchange sequence number (0 = not tracked)
    Price price;            // Price level
    Quantity quantity;      // New total quantity at this level (0 = delete)
    SymbolId symbol;        // Symbol identifier
    uint16_t level_index;   // 0-based index in sorted order (0 = best, 1 = second best, etc.)
    uint16_t num_orders;    // number of orders on the level
    uint8_t change_flags;   // Bitset of ChangeFlag
    Side side;              // Buy or Sell
 
    PriceLevelUpdate() noexcept = default;
 
    PriceLevelUpdate(Timestamp ts, SymbolId sym, Side s, Price p, Quantity q, uint16_t order_count = 0,
                     uint16_t idx = 0, uint8_t flags = 0, uint64_t seq = 0) noexcept
        : timestamp(ts), seq_num(seq), price(p), quantity(q), symbol(sym),
          level_index(idx), num_orders(order_count), change_flags(flags), side(s) {}
 
    [[nodiscard]] constexpr bool isDelete() const noexcept {
        return quantity == 0;
    }
 
    [[nodiscard]] constexpr bool priceChanged() const noexcept {
        return (change_flags & PriceChanged) != 0;
    }
 
    [[nodiscard]] constexpr bool quantityChanged() const noexcept {
        return (change_flags & QuantityChanged) != 0;
    }
 
    [[nodiscard]] constexpr bool isTopN(uint16_t n) const noexcept {
        return level_index < n;
    }
 
    [[nodiscard]] constexpr bool isLastInBatch() const noexcept {
        return (change_flags & LastInBatch) != 0;
    }
};
 
struct OrderUpdate {
    Timestamp timestamp;        // Update timestamp
    uint64_t seq_num;           // Exchange sequence number (0 = not tracked)
    OrderId order_id;           // Unique order identifier
    Price price;                // Order price
    Quantity quantity;          // Order quantity (0 = delete)
    Price old_price;            // Old order price
    Quantity old_qty;           // Old order quantity
    SymbolId symbol;            // Symbol identifier
    uint16_t price_level_index; // Index of the price level this order belongs to
    uint64_t priority;          // Order priority (typically timestamp or sequence number)
    Side side;                  // Buy or Sell
    uint8_t change_flags;       // Bitset of ChangeFlag
 
    OrderUpdate() noexcept = default;
 
    OrderUpdate(SymbolId sym, OrderId id, Side s, Price p, Quantity q, Price op, Quantity oq, Timestamp ts,
                uint16_t idx = 0, uint64_t prio = 0, uint8_t flags = 0, uint64_t seq = 0) noexcept
        : timestamp(ts), seq_num(seq), order_id(id), price(p), quantity(q), old_price(op), old_qty(oq), symbol(sym), 
          price_level_index(idx), priority(prio), side(s), change_flags(flags)  {}
 
    [[nodiscard]] constexpr bool isDelete() const noexcept {
        return quantity == 0;
    }
 
    [[nodiscard]] constexpr bool priceChanged() const noexcept {
        return (change_flags & PriceChanged) != 0;
    }
 
    [[nodiscard]] constexpr bool quantityChanged() const noexcept {
        return (change_flags & QuantityChanged) != 0;
    }
 
    [[nodiscard]] constexpr bool isTopN(uint16_t n) const noexcept {
        return price_level_index < n;
    }
 
    [[nodiscard]] constexpr bool isLastInBatch() const noexcept {
        return (change_flags & LastInBatch) != 0;
    }
};
 
struct Trade {
    SymbolId symbol;                // Symbol identifier
    Price price;                    // Trade price
    Quantity quantity;              // Trade quantity
    Timestamp timestamp;            // Trade timestamp
    OrderId aggressive_order_id;    // OrderId of the aggressive (incoming) order
    OrderId passive_order_id;       // OrderId of the passive (resting) order
    Side aggressor_side;            // Side that initiated the trade (Buy = uptick, Sell = downtick)
    uint8_t change_flags;           // Bitset of ChangeFlag
 
    Trade() noexcept : symbol(0), price(0), quantity(0), timestamp(0),
                       aggressive_order_id(0), passive_order_id(0),
                       aggressor_side(Side::Buy), change_flags(0) {}
 
    Trade(SymbolId sym, Price p, Quantity q, Timestamp ts, Side aggressor,
          OrderId passive = 0, OrderId aggressive = 0, uint8_t flags = 0) noexcept
        : symbol(sym), price(p), quantity(q), timestamp(ts),
          aggressive_order_id(aggressive), passive_order_id(passive),
          aggressor_side(aggressor), change_flags(flags) {}
 
    [[nodiscard]] constexpr bool isLastInBatch() const noexcept {
        return (change_flags & LastInBatch) != 0;
    }
};
 
struct TopOfBook {
    SymbolId symbol;                              // Symbol identifier
    Price best_bid;                               // Best bid price (highest buy price)
    Quantity bid_quantity;                        // Total quantity at best bid
    Price best_ask;                               // Best ask price (lowest sell price)
    Quantity ask_quantity;                        // Total quantity at best ask
    Timestamp timestamp;                          // Snapshot timestamp
    std::array<uint8_t, 2> change_flags {0, 0};   // Bitset of ChangeFlag
 
    TopOfBook() noexcept
        : symbol(0), best_bid(0), bid_quantity(0), best_ask(0), ask_quantity(0), timestamp(0) {}
 
    TopOfBook(SymbolId sym, Price bid, Quantity bid_qty, Price ask, Quantity ask_qty, Timestamp ts) noexcept
        : symbol(sym), best_bid(bid), bid_quantity(bid_qty), best_ask(ask), ask_quantity(ask_qty), timestamp(ts) {}
 
    [[nodiscard]] Price spread() const noexcept {
        return (best_ask > best_bid) ? (best_ask - best_bid) : 0;
    }
 
    [[nodiscard]] Price midPrice() const noexcept {
        return (best_bid + best_ask) / 2;
    }
 
    [[nodiscard]] bool isCrossed() const noexcept {
        return best_bid >= best_ask && best_bid > 0 && best_ask > 0;
    }
 
    [[nodiscard]] bool hasBid() const noexcept {
        return best_bid > 0 && bid_quantity > 0;
    }
 
    [[nodiscard]] bool hasAsk() const noexcept {
        return best_ask > 0 && ask_quantity > 0;
    }
 
    [[nodiscard]] bool isValid() const noexcept {
        return hasBid() && hasAsk();
    }
};
 
SLICK_NAMESPACE_END