orderbook_l2.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/level_container.hpp>
#include <memory>
#include <vector>
#include <array>
#include <atomic>
 
SLICK_NAMESPACE_BEGIN
 
SLICK_DLL_INTERFACE_WARNINGS_PUSH
class SLICK_API SLICK_CACHE_ALIGNED OrderBookL2 {
public:
    explicit OrderBookL2(SymbolId symbol, std::size_t initial_capacity = 32);
 
    virtual ~OrderBookL2() = default;
 
    // Non-copyable, movable (manual implementation due to std::atomic member)
    OrderBookL2(const OrderBookL2&) = delete;
    OrderBookL2& operator=(const OrderBookL2&) = delete;
    OrderBookL2(OrderBookL2&&) noexcept;
    OrderBookL2& operator=(OrderBookL2&&) noexcept;
 
    [[nodiscard]] SymbolId symbol() const noexcept { return symbol_; }
 
    void updateLevel(Side side, Price price, Quantity quantity, Timestamp timestamp,
                     uint64_t seq_num = 0, bool is_last_in_batch = true);
 
    bool deleteLevel(Side side, Price price, Timestamp timestamp = 0);
 
    void clearSide(Side side, Timestamp timestamp = 0);
 
    void clear(Timestamp timestamp = 0);
 
    [[nodiscard]] const detail::PriceLevelL2* getBestBid() const noexcept;
 
    [[nodiscard]] const detail::PriceLevelL2* getBestAsk() const noexcept;
 
    [[nodiscard]] TopOfBook getTopOfBook() const noexcept;
 
    [[nodiscard]] std::vector<detail::PriceLevelL2> getLevels(Side side, std::size_t depth = 0) const;
 
    [[nodiscard]] const detail::PriceLevelL2* getLevel(Side side, Price price) const noexcept;
 
    [[nodiscard]] const detail::PriceLevelL2* getLevelByIndex(Side side, uint16_t index) const noexcept;
 
    [[nodiscard]] std::size_t levelCount(Side side) const noexcept;
 
    [[nodiscard]] bool isEmpty(Side side) const noexcept;
 
    [[nodiscard]] bool isEmpty() const noexcept;
 
    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:
    void notifyTopOfBookIfChanged(Timestamp timestamp);
 
    SymbolId symbol_;                                                   // Symbol identifier
    std::array<detail::LevelContainer, SideCount> sides_;               // Bid and ask sides (indexed by Side enum)
    ObserverManager observers_;                                         // Observer notifications
    TopOfBook cached_tob_;                                              // Cached top-of-book for efficient change detection
    detail::PriceLevelL2 cached_best_bid_;                              // Cached best bid (for thread-safe access)
    detail::PriceLevelL2 cached_best_ask_;                              // Cached best ask (for thread-safe access)
    std::atomic<uint64_t> tob_seq_;                                     // Sequence lock for cached_tob_ and best bid/ask (odd = writing, even = readable)
    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
};
SLICK_DLL_INTERFACE_WARNINGS_POP
 
SLICK_NAMESPACE_END
 
// Include implementation for header-only mode
#ifdef SLICK_ORDERBOOK_HEADER_ONLY
#include <slick/orderbook/detail/impl/orderbook_l2_impl.hpp>
#endif