order_book.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <cstdint>
#include <functional>
#include <list>
#include <map>
#include <memory>
#include <ostream>
#include <set>
#include <variant>
 
#include "itch/messages.hpp"
 
namespace itch {
 
struct PriceLevel;
 
struct Order {
    uint64_t order_reference_number;  
    char     buy_sell_indicator;      
    uint32_t shares;                  
    uint32_t price;                   
    PriceLevel* level;                
    std::string stock;                
 
    Order(uint64_t ref_num, char side, uint32_t shrs, uint32_t prc, const std::string& stk)
        : order_reference_number {ref_num},
          buy_sell_indicator {side},
          shares {shrs},
          price {prc},
          level {nullptr},
          stock {stk} {}
};
 
using OrderIt = std::list<std::shared_ptr<Order>>::iterator;
 
struct PriceLevel {
    uint32_t total_shares {0};                 
    std::list<std::shared_ptr<Order>> orders;  
 
    auto add_order(const std::shared_ptr<Order>& order) -> void;
 
    auto remove_order(const OrderIt& order_it) -> void;
};
 
class LimitOrderBook {
   public:
    LimitOrderBook(const std::string& stock_symbol) : m_stock_symbol(stock_symbol) {}
    auto process(const Message& message) -> void;
 
    auto print(std::ostream& out, unsigned int delay_ms = 0) const -> void;
 
    // Type aliases for the bid and ask maps (sorted containers).
    using BidMap = std::map<uint32_t, PriceLevel, std::greater<uint32_t>>;
    using AskMap = std::map<uint32_t, PriceLevel, std::less<uint32_t>>;
 
    auto get_bids() const -> const BidMap& { return m_bids; }
 
    auto get_asks() const -> const AskMap& { return m_asks; }
 
    const std::set<char> book_messages {'A', 'F', 'E', 'C', 'X', 'D', 'U'};
 
   private:
    std::string                 m_stock_symbol;
    BidMap                      m_bids;  
    AskMap                      m_asks;  
    std::map<uint64_t, OrderIt> m_orders;  
 
    // Message Handlers
    auto handle_message(const AddOrderMessage& msg) -> void;
 
    auto handle_message(const AddOrderMPIDAttributionMessage& msg) -> void;
 
    auto handle_message(const OrderExecutedMessage& msg) -> void;
 
    auto handle_message(const OrderExecutedWithPriceMessage& msg) -> void;
 
    auto handle_message(const OrderCancelMessage& msg) -> void;
 
    auto handle_message(const OrderDeleteMessage& msg) -> void;
 
    auto handle_message(const OrderReplaceMessage& msg) -> void;
 
    template <typename T>
    auto handle_message(const T& /* msg */) -> void { /* No-op for irrelevant messages */ }
 
    auto add_order(
        uint64_t order_ref, char side, uint32_t shares, uint32_t price, const std::string& stock
    ) -> void;
 
    auto remove_order(uint64_t order_ref, uint32_t canceled_shares) -> void;
};
 
}  // namespace itch