order_book.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <map>
#include <list>
#include <unordered_map>
#include <vector>
#include <functional>
#include <optional>
#include "app/model/order.hpp"
 
namespace fix40 {
 
struct Trade {
    std::string tradeID;           
    std::string symbol;            
    double price;                  
    int64_t qty;                   
    std::chrono::system_clock::time_point timestamp;  
 
    // 买方信息
    std::string buyOrderID;        
    std::string buyClOrdID;        
    int64_t buyOrderQty;           
    double buyPrice;               
    OrderType buyOrdType;          
    int64_t buyCumQty;             
    int64_t buyLeavesQty;          
    double buyAvgPx;               
    OrderStatus buyStatus;         
 
    // 卖方信息
    std::string sellOrderID;       
    std::string sellClOrdID;       
    int64_t sellOrderQty;          
    double sellPrice;              
    OrderType sellOrdType;         
    int64_t sellCumQty;            
    int64_t sellLeavesQty;         
    double sellAvgPx;              
    OrderStatus sellStatus;        
 
    Trade() 
        : price(0.0), qty(0)
        , buyOrderQty(0), buyPrice(0.0), buyOrdType(OrderType::LIMIT)
        , buyCumQty(0), buyLeavesQty(0), buyAvgPx(0.0), buyStatus(OrderStatus::NEW)
        , sellOrderQty(0), sellPrice(0.0), sellOrdType(OrderType::LIMIT)
        , sellCumQty(0), sellLeavesQty(0), sellAvgPx(0.0), sellStatus(OrderStatus::NEW)
    {}
};
 
struct PriceLevel {
    double price;                  
    std::list<Order> orders;       
    int64_t totalQty;              
 
    explicit PriceLevel(double p = 0.0) : price(p), totalQty(0) {}
 
    bool empty() const { return orders.empty(); }
};
 
class OrderBook {
public:
    explicit OrderBook(const std::string& symbol);
 
    const std::string& getSymbol() const { return symbol_; }
 
    // =========================================================================
    // 订单操作
    // =========================================================================
 
    std::vector<Trade> addOrder(Order& order);
 
    std::optional<Order> cancelOrder(const std::string& clOrdID);
 
    const Order* findOrder(const std::string& clOrdID) const;
 
    // =========================================================================
    // 行情查询
    // =========================================================================
 
    std::optional<double> getBestBid() const;
 
    std::optional<double> getBestAsk() const;
 
    std::vector<PriceLevel> getBidLevels(size_t levels = 5) const;
 
    std::vector<PriceLevel> getAskLevels(size_t levels = 5) const;
 
    size_t getBidOrderCount() const { return bidOrderCount_; }
 
    size_t getAskOrderCount() const { return askOrderCount_; }
 
    bool empty() const { return bids_.empty() && asks_.empty(); }
 
private:
    std::string generateOrderID();
 
    std::string generateTradeID();
 
    std::vector<Trade> matchBuyOrder(Order& order);
 
    std::vector<Trade> matchSellOrder(Order& order);
 
    void addToBids(const Order& order);
 
    void addToAsks(const Order& order);
 
    std::optional<Order> removeOrder(const std::string& clOrdID, OrderSide side);
 
    int64_t calculateMatchableQty(const Order& order) const;
 
    std::string symbol_;  
 
    std::map<double, PriceLevel, std::greater<double>> bids_;
    
    std::map<double, PriceLevel, std::less<double>> asks_;
 
    struct OrderLocation {
        OrderSide side;
        double price;
    };
    std::unordered_map<std::string, OrderLocation> orderIndex_;
 
    size_t bidOrderCount_ = 0;   
    size_t askOrderCount_ = 0;   
    uint64_t nextOrderID_ = 1;   
    uint64_t nextTradeID_ = 1;   
};
 
} // namespace fix40