orderbook_l3.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 <slick/orderbook/events.hpp>
#include <slick/orderbook/observer.hpp>
#include <slick/orderbook/detail/price_level_l2.hpp>
#include <slick/orderbook/detail/price_level_l3.hpp>
#include <slick/orderbook/detail/order.hpp>
#include <slick/orderbook/detail/order_map.hpp>
#include <slick/orderbook/detail/memory_pool.hpp>
#include <slick/orderbook/detail/flat_map.hpp>
#include <slick/orderbook/detail/intrusive_list.hpp>
#include <memory>
#include <algorithm>
#include <vector>
#include <array>
#include <tuple>
#include <functional>
 
SLICK_NAMESPACE_BEGIN
 
SLICK_DLL_INTERFACE_WARNINGS_PUSH
class SLICK_API SLICK_CACHE_ALIGNED OrderBookL3 {
public:
    struct PriceComparator {
        using Comparator = std::function<bool(Price, Price)>;
        Comparator compare_;
 
        // Default constructor (for array initialization on MSVC)
        PriceComparator() : compare_(detail::BidComparatorL3{}) {}
 
        explicit PriceComparator(Side side)
            : compare_(side == Side::Buy
                ? Comparator{detail::BidComparatorL3{}}
                : Comparator{detail::AskComparatorL3{}}
            )
        {}
        bool operator()(Price a, Price b) const noexcept {
            return compare_(a, b);
        }
    };
    using PriceLevelMap = detail::FlatMap<Price, detail::PriceLevelL3, PriceComparator>;
 
    explicit OrderBookL3(SymbolId symbol,
                        std::size_t interested_num_levels = 10,
                        std::size_t initial_order_capacity = 1024,
                        std::size_t initial_level_capacity = 32);
 
    virtual ~OrderBookL3();
 
    // Non-copyable, movable
    OrderBookL3(const OrderBookL3&) = delete;
    OrderBookL3& operator=(const OrderBookL3&) = delete;
    OrderBookL3(OrderBookL3&&) noexcept = default;
    OrderBookL3& operator=(OrderBookL3&&) noexcept = default;
 
    [[nodiscard]] SymbolId symbol() const noexcept { return symbol_; }
 
    bool addOrModifyOrder(OrderId order_id, Side side, Price price, Quantity quantity,
                          Timestamp timestamp, uint64_t priority,
                          uint64_t seq_num = 0, bool is_last_in_batch = true);
 
    bool addOrder(OrderId order_id, Side side, Price price, Quantity quantity,
                  Timestamp timestamp, uint64_t priority = 0, uint64_t seq_num = 0, bool is_last_in_batch = true);
 
    bool modifyOrder(OrderId order_id, Price new_price, Quantity new_quantity,
                     Timestamp new_timestamp, uint64_t new_priority = 0,
                     uint64_t seq_num = 0, bool is_last_in_batch = true);
 
    bool deleteOrder(OrderId order_id, Timestamp timestamp, uint64_t seq_num = 0, bool is_last_in_batch = true);
 
    virtual bool executeOrder(OrderId order_id, Quantity executed_quantity, Timestamp timestamp,
                      uint64_t seq_num = 0, bool is_last_in_batch = true);
 
    [[nodiscard]] const detail::Order* findOrder(OrderId order_id) const noexcept;
 
    template<Side SIDE>
    [[nodiscard]] const detail::PriceLevelL3* getBestLevel() const noexcept;
 
    [[nodiscard]] const detail::PriceLevelL3* getBestBid() const noexcept;
 
    [[nodiscard]] const detail::PriceLevelL3* getBestAsk() const noexcept;
 
    [[nodiscard]] TopOfBook getTopOfBook() const noexcept;
 
    [[nodiscard]] const PriceLevelMap& getLevelsL3(Side side) const noexcept {
        SLICK_ASSERT(side < SideCount);
        return levels_[side];
    }
 
    [[nodiscard]] std::vector<detail::PriceLevelL2> getLevelsL2(Side side, std::size_t depth = 0) const;
 
    [[nodiscard]] std::pair<const detail::PriceLevelL3*, uint16_t> getLevel(Side side, Price price) const noexcept;
 
    [[nodiscard]] std::pair<detail::PriceLevelL3*, uint16_t> getLevel(Side side, Price price) noexcept;
 
    [[nodiscard]] const detail::PriceLevelL3* getLevelByIndex(Side side, uint16_t index) const noexcept;
 
    [[nodiscard]] std::size_t levelCount(Side side) const noexcept;
 
    [[nodiscard]] std::size_t orderCount() const noexcept { return order_map_.size(); }
 
    [[nodiscard]] std::size_t orderCount(Side side) const noexcept;
 
    [[nodiscard]] bool isEmpty(Side side) const noexcept;
 
    [[nodiscard]] bool isEmpty() const noexcept;
 
    void clearSide(Side side, Timestamp timestamp = 0);
 
    void clear(Timestamp timestamp = 0);
 
    void addObserver(std::shared_ptr<IOrderBookObserver> observer) {
        observers_.addObserver(std::move(observer));
    }
 
    bool removeObserver(const std::shared_ptr<IOrderBookObserver>& observer) {
        return observers_.removeObserver(observer);
    }
 
    void clearObservers() noexcept {
        observers_.clearObservers();
    }
 
    [[nodiscard]] std::size_t observerCount() const noexcept {
        return observers_.observerCount();
    }
 
    [[nodiscard]] uint64_t getLastSeqNum() const noexcept {
        return last_seq_num_;
    }
 
    void emitSnapshot(Timestamp timestamp);
 
protected:
    std::tuple<detail::PriceLevelL3*, uint16_t, bool> getOrCreateLevel(Side side, Price price);
 
    bool removeLevelIfEmpty(Side side, Price price) noexcept;
 
    void releaseSide(Side side) noexcept;
 
    void notifyOrderUpdate(const detail::Order* order, Quantity old_quantity, Price old_price,
                          Timestamp timestamp, uint16_t level_index, uint8_t change_flags, uint64_t seq_num) const;
 
    void notifyOrderDelete(const detail::Order* order, Timestamp timestamp, uint16_t level_index, uint8_t change_flags, uint64_t seq_num) const;
 
    [[nodiscard]] uint16_t calculateLevelIndex(Side side, Price price) const noexcept;
 
    void notifyTrade(OrderId passive_order_id, OrderId aggressive_order_id,
                     Side aggressor_side, Price price, Quantity quantity, Timestamp timestamp) const;
 
    void notifyPriceLevelUpdate(Timestamp timestamp, Side side, Price price, Quantity total_quantity, size_t order_count, uint16_t level_index, uint8_t change_flags, uint64_t seq_num) const;
 
    void notifyTopOfBookIfChanged(Timestamp timestamp);
 
protected:
    SymbolId symbol_;                                           // Symbol identifier
    std::array<PriceLevelMap, SideCount> levels_;               // Price levels per side (indexed by Side enum)
    detail::OrderMap order_map_;                                // OrderId -> Order* lookup
    detail::ObjectPool<detail::Order> order_pool_;              // Memory pool for Order objects
    ObserverManager observers_;                                 // Observer notifications
    TopOfBook cached_tob_;                                      // Cached top-of-book for efficient change detection
    uint64_t last_seq_num_;                                     // Last processed sequence number (0 = not tracking)
    uint16_t change_starting_index_ = INVALID_INDEX;            // The lowerest level had changed in a batch. The value reset to INVALID_INDEX after TopOfBook change notified
    std::size_t interested_num_levels_;                         // The top N levels to track for observer notifications (0 = all levels)
};
SLICK_DLL_INTERFACE_WARNINGS_POP
 
template<>
inline const detail::PriceLevelL3* OrderBookL3::getBestLevel<Side::Buy>() const noexcept {
    return getBestBid();
}
 
template<>
inline const detail::PriceLevelL3* OrderBookL3::getBestLevel<Side::Sell>() const noexcept {
    return getBestAsk();
}   
 
SLICK_NAMESPACE_END
 
// Include implementation for header-only mode
#ifdef SLICK_ORDERBOOK_HEADER_ONLY
#include <slick/orderbook/detail/impl/orderbook_l3_impl.hpp>
#endif