orderbook.cpp

#include <iostream>
#include <map>
#include <deque>
#include <unordered_map>
#include <algorithm>

enum class Side { Buy, Sell };

class Order {
public:
    Order(int id, Side side, double price, int quantity)
        : id(id), side(side), price(price), quantity(quantity) {}

    int getId() const { return id; }
    Side getSide() const { return side; }
    double getPrice() const { return price; }
    int getQuantity() const { return quantity; }
    void setQuantity(int qty) { quantity = qty; }

private:
    int id;
    Side side;
    double price;
    int quantity;
};

class OrderBook {
private:
    std::map<double, std::deque<Order>, std::greater<double>> buyOrders;
    std::map<double, std::deque<Order>, std::less<double>> sellOrders;
    std::unordered_map<int, std::tuple<Side, double, std::deque<Order>::iterator>> orderIndex;

    std::deque<Order>& getOrderQueue(Side side, double price) {
        return (side == Side::Buy) ? buyOrders[price] : sellOrders[price];
    }

    void removeEmptyPriceLevel(Side side, double price) {
        if (side == Side::Buy && buyOrders[price].empty()) {
            buyOrders.erase(price);
        } else if (side == Side::Sell && sellOrders[price].empty()) {
            sellOrders.erase(price);
        }
    }

    void matchOrder(Order& incomingOrder) {
        if (incomingOrder.getSide() == Side::Buy) {
            while (incomingOrder.getQuantity() > 0 && !sellOrders.empty()) {
                auto& [price, orders] = *sellOrders.begin();
                if (incomingOrder.getPrice() < price) break;
                
                while (!orders.empty() && incomingOrder.getQuantity() > 0) {
                    Order& existingOrder = orders.front();
                    int matchQuantity = std::min(incomingOrder.getQuantity(), existingOrder.getQuantity());
                    
                    incomingOrder.setQuantity(incomingOrder.getQuantity() - matchQuantity);
                    existingOrder.setQuantity(existingOrder.getQuantity() - matchQuantity);
                    
                    if (existingOrder.getQuantity() == 0) {
                        orderIndex.erase(existingOrder.getId());
                        orders.pop_front();
                    }
                }
                
                if (orders.empty()) {
                    sellOrders.erase(sellOrders.begin());
                }
            }
        } else {
            while (incomingOrder.getQuantity() > 0 && !buyOrders.empty()) {
                auto& [price, orders] = *buyOrders.begin();
                if (incomingOrder.getPrice() > price) break;
                
                while (!orders.empty() && incomingOrder.getQuantity() > 0) {
                    Order& existingOrder = orders.front();
                    int matchQuantity = std::min(incomingOrder.getQuantity(), existingOrder.getQuantity());
                    
                    incomingOrder.setQuantity(incomingOrder.getQuantity() - matchQuantity);
                    existingOrder.setQuantity(existingOrder.getQuantity() - matchQuantity);
                    
                    if (existingOrder.getQuantity() == 0) {
                        orderIndex.erase(existingOrder.getId());
                        orders.pop_front();
                    }
                }
                
                if (orders.empty()) {
                    buyOrders.erase(buyOrders.begin());
                }
            }
        }
    }

public:
    bool addOrder(int id, Side side, double price, int quantity) {
        if (orderIndex.find(id) != orderIndex.end()) return false;

        Order newOrder(id, side, price, quantity);
        matchOrder(newOrder);
        
        if (newOrder.getQuantity() > 0) {
            auto& queue = getOrderQueue(side, price);
            queue.push_back(newOrder);
            orderIndex[id] = std::make_tuple(side, price, std::prev(queue.end()));
        }
        
        return true;
    }

    bool cancelOrder(int id) {
        auto it = orderIndex.find(id);
        if (it == orderIndex.end()) return false;

        auto [side, price, orderIt] = it->second;
        auto& queue = getOrderQueue(side, price);
        queue.erase(orderIt);
        orderIndex.erase(it);
        removeEmptyPriceLevel(side, price);
        
        return true;
    }

    void printBook() const {
        std::cout << "\n=== Order Book ===\n";
        
        std::cout << "SELLS:\n";
        for (auto it = sellOrders.rbegin(); it != sellOrders.rend(); ++it) {
            int totalQty = 0;
            for (const auto& order : it->second) totalQty += order.getQuantity();
            std::cout << "  " << it->first << " x " << totalQty << "\n";
        }
        
        std::cout << "BUYS:\n";
        for (const auto& [price, orders] : buyOrders) {
            int totalQty = 0;
            for (const auto& order : orders) totalQty += order.getQuantity();
            std::cout << "  " << price << " x " << totalQty << "\n";
        }
    }
};

int main() {
    OrderBook book;
    
    std::cout << "Order Book Demo\n";
    
    book.addOrder(1, Side::Buy, 99.50, 100);
    book.addOrder(2, Side::Buy, 99.00, 200);
    book.addOrder(3, Side::Sell, 100.50, 150);
    book.addOrder(4, Side::Sell, 101.00, 100);
    
    book.printBook();
    
    std::cout << "\nAdding matching order...\n";
    book.addOrder(5, Side::Buy, 100.50, 75);
    book.printBook();
    
    std::cout << "\nDemo completed!\n";
    return 0;
}