l3_book.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
#include "itch/book/order_index.hpp"
#include "itch/price.hpp"
 
namespace itch::book {
 
enum class Side : char {
    buy  = 'B',  
    sell = 'S',  
};
 
struct DepthLevel {
    StandardPrice price {};         
    std::uint64_t shares {0};       
    std::uint32_t order_count {0};  
};
 
struct OrderView {
    std::uint64_t reference_number {0};  
    std::uint32_t shares {0};            
    StandardPrice price {};              
};
 
struct Bbo {
    bool          has_bid {false};  
    bool          has_ask {false};  
    StandardPrice bid_price {};     
    std::uint64_t bid_shares {0};   
    StandardPrice ask_price {};     
    std::uint64_t ask_shares {0};   
 
    [[nodiscard]] friend auto operator==(const Bbo&, const Bbo&) noexcept -> bool = default;
};
 
class L3Book {
   public:
    explicit L3Book(std::string symbol = {});
 
    auto set_symbol(std::string symbol) -> void { m_symbol = std::move(symbol); }
 
    [[nodiscard]] auto symbol() const noexcept -> const std::string& { return m_symbol; }
 
    auto add_order(
        std::uint64_t reference_number, Side side, std::uint32_t shares, std::uint32_t price
    ) -> void;
 
    auto execute_order(std::uint64_t reference_number, std::uint32_t shares) -> std::uint32_t;
 
    auto reduce_order(std::uint64_t reference_number, std::uint32_t shares) -> std::uint32_t;
 
    auto delete_order(std::uint64_t reference_number) -> void;
 
    auto replace_order(
        std::uint64_t old_reference_number,
        std::uint64_t new_reference_number,
        std::uint32_t shares,
        std::uint32_t price
    ) -> void;
 
    [[nodiscard]] auto contains(std::uint64_t reference_number) const -> bool;
 
    [[nodiscard]] auto order_price(std::uint64_t reference_number
    ) const -> std::optional<std::uint32_t>;
 
    [[nodiscard]] auto order_side(std::uint64_t reference_number) const -> std::optional<Side>;
 
    [[nodiscard]] auto bbo() const -> Bbo;
 
    [[nodiscard]] auto depth(Side side, std::size_t max_levels = 0) const
        -> std::vector<DepthLevel>;
 
    [[nodiscard]] auto orders_at(Side side, std::uint32_t price) const -> std::vector<OrderView>;
 
    [[nodiscard]] auto level_count(Side side) const noexcept -> std::size_t;
 
    [[nodiscard]] auto empty() const noexcept -> bool { return m_index.empty(); }
 
   private:
    static constexpr std::uint32_t NIL = 0xFFFFFFFFU;
 
    struct OrderNode {
        std::uint64_t reference_number {0};
        std::uint32_t shares {0};
        std::uint32_t price {0};
        Side          side {Side::buy};
        std::uint32_t next {NIL};  
        std::uint32_t prev {NIL};  
    };
 
    struct Level {
        std::uint32_t price {0};
        std::uint64_t total_shares {0};
        std::uint32_t order_count {0};
        std::uint32_t head {NIL};
        std::uint32_t tail {NIL};
    };
 
    [[nodiscard]] auto side_levels(Side side) noexcept -> std::vector<Level>&;
 
    [[nodiscard]] auto side_levels(Side side) const noexcept -> const std::vector<Level>&;
 
    auto allocate_node() -> std::uint32_t;
 
    auto free_node(std::uint32_t node_index) -> void;
 
    [[nodiscard]] auto find_level(Side side, std::uint32_t price) const -> std::uint32_t;
 
    auto find_or_create_level(Side side, std::uint32_t price) -> std::uint32_t;
 
    auto unlink_node(std::uint32_t node_index) -> void;
 
    std::string            m_symbol;
    std::vector<OrderNode> m_pool;
    std::uint32_t          m_free_head {NIL};
    std::vector<Level>     m_bids;  
    std::vector<Level>     m_asks;  
    // Reference-number -> pool index for O(1), allocation-free order lookup.
    OrderIndex m_index;
};
 
}  // namespace itch::book