lob.cc

#include <iostream>
#include <map>
#include <list>
#include <unordered_map>
#include <algorithm>
using namespace std;

using ll = long long;
enum Side {Buy, Sell};

struct Order {
    u_int64_t id;
    ll price;
    u_int32_t quantity;
    Side side;
};

using lo = list<Order>;

class OrderBook {
public:
    bool addOrder(Order x) {
        if (order_ref.count(x.id)) {
            cout << "[ERROR] Order ID " << x.id << " already exists\n";
            return false;
        }

        match(x);

        if (x.quantity > 0) {
            if (x.side == Buy) {
                auto& lst = bids[x.price];
                lst.push_back(x);
                order_ref[x.id] = {x.price, Buy, prev(lst.end())};
            } else {
                auto& lst = asks[x.price];
                lst.push_back(x);
                order_ref[x.id] = {x.price, Sell, prev(lst.end())};
            }
        }
        return true;
    }

    bool modifyOrder(u_int64_t orderID, u_int32_t newQuantity) {
        if (order_ref.find(orderID) == order_ref.end()) {
            cout << "[ERROR] Order ID " << orderID << " not found\n";
            return false;
        }
        if (newQuantity == 0) {
            cancelOrder(orderID);
            return true;
        }
        auto& ref = order_ref[orderID];
        ref.it->quantity = newQuantity;
        cout << "Order " << orderID << " modified to qty " << newQuantity << "\n";
        return true;
    }
    void cancelOrder(u_int64_t orderID) {
        if (order_ref.find(orderID) == order_ref.end()) return;

        auto ref = order_ref[orderID];
        if (ref.side == Buy) {
            bids[ref.price].erase(ref.it);
            if (bids[ref.price].empty()) bids.erase(ref.price);
        }
        else {
            asks[ref.price].erase(ref.it);
            if (asks[ref.price].empty()) asks.erase(ref.price);
        }
        order_ref.erase(orderID);
        cout << "Order " << orderID << " cancelled\n";
    }

   void display() {
        cout << "\n===========================================" << endl;
        cout << "                ORDER BOOK                 " << endl;
        cout << "===========================================" << endl;
        
        cout << "--- ASKS (Sellers) ---" << endl;
        // Asks displayed from highest to lowest so Best Ask is near the bids
        for (auto it = asks.rbegin(); it != asks.rend(); ++it) {
            u_int32_t totalQty = 0;
            for (const auto& o : it->second) totalQty += o.quantity;
            cout << "  Price: " << it->first << " | Quantity: " << totalQty << endl;
        }

        cout << "-------------------------------------------" << endl;
        cout << "  Spread: " << ( (!asks.empty() && !bids.empty()) ? (asks.begin()->first - bids.begin()->first) : 0 ) << endl;
        cout << "-------------------------------------------" << endl;

        cout << "--- BIDS (Buyers) ---" << endl;
        for (auto const& [price, orders] : bids) {
            u_int32_t totalQty = 0;
            for (const auto& o : orders) totalQty += o.quantity;
            cout << "  Price: " << price << " | Quantity: " << totalQty << endl;
        }
        cout << "===========================================\n" << endl;
    }

    ll getBestBid() const { return bids.empty() ? -1 : bids.begin()->first; }
    ll getBestAsk() const { return asks.empty() ? -1 : asks.begin()->first; }
    ll getSpread() const {
        if (bids.empty() || asks.empty()) return -1;
        return asks.begin()->first - bids.begin()->first;
    }
    bool empty() const { return bids.empty() && asks.empty(); }

private:
    map<ll, lo, greater<ll>> bids;
    map<ll, lo> asks;
    struct OrderEntry {
        ll price;
        Side side;
        lo::iterator it;
    };
    unordered_map<u_int64_t, OrderEntry> order_ref;

    void match(Order& new_order) {
        if (new_order.side == Buy)
            matchSide(new_order, asks);
        else
            matchSide(new_order, bids);
    }

    template<typename T_MAP>
    void matchSide(Order& new_order, T_MAP& op_side) {
        auto it = op_side.begin();
        while (it != op_side.end() && new_order.quantity > 0) {
            ll best = it -> first;
            if((new_order.side == Buy) ? (new_order.price >= best) : (new_order.price <= best)) {
                auto& listatprice = it -> second;
                while(!listatprice.empty() && new_order.quantity > 0) {
                    Order& rest = listatprice.front();
                    u_int32_t tradeQuant = min(new_order.quantity, rest.quantity);
                    cout << "[TRADE] ID " << new_order.id << " matched with ID " << rest.id 
                    << " | Qty: " << tradeQuant << " | Price: " << best << endl;

                    new_order.quantity -= tradeQuant;
                    rest.quantity -= tradeQuant;
                    if(!rest.quantity) {
                        order_ref.erase(rest.id);
                        listatprice.pop_front();
                    }
                }
                if (listatprice.empty())
                    it = op_side.erase(it);
                else
                    break;
            } else {
                break; // price doesn't cross, no more matches possible
            }
        }
    }
};

int main() {
    OrderBook book;

    cout << "--- Placing initial orders ---" << endl;
    book.addOrder({1, 100, 10, Buy});
    book.addOrder({2, 105, 5, Sell});
    book.addOrder({3, 106, 15, Sell});
    book.display();

    cout << "--- Executing aggressive buy (ID 4) ---" << endl;
    book.addOrder({4, 107, 10, Buy});
    book.display();

    cout << "--- Modifying order ID 3 (qty 15 -> 8) ---" << endl;
    book.modifyOrder(3, 8);
    book.display();

    cout << "--- Cancelling order ID 3 ---" << endl;
    book.cancelOrder(3);
    book.display();

    cout << "--- Attempting duplicate ID ---" << endl;
    book.addOrder({1, 99, 5, Buy});

    cout << "\n--- Info ---" << endl;
    cout << "Best Bid: " << book.getBestBid() << endl;
    cout << "Best Ask: " << book.getBestAsk() << endl;
    cout << "Spread:   " << book.getSpread() << endl;

    return 0;
}