price_level_l3.hpp

Go to the documentation of this file.

// Copyright 2026 Slick Quant
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <slick/orderbook/config.hpp>
#include <slick/orderbook/types.hpp>
#include <slick/orderbook/detail/intrusive_list.hpp>
#include <slick/orderbook/detail/order.hpp>
 
SLICK_DETAIL_NAMESPACE_BEGIN
 
struct PriceLevelL3 {
    Price price;                    // Price level
    IntrusiveList<Order> orders;    // Orders at this price (sorted by priority)
    Quantity total_quantity;        // Cached total quantity for fast L2 aggregation
 
    explicit PriceLevelL3(Price p) noexcept
        : price(p), orders(), total_quantity(0) {}
 
    [[nodiscard]] Quantity getTotalQuantity() const noexcept {
        return total_quantity;
    }
 
    [[nodiscard]] std::size_t orderCount() const noexcept {
        return orders.size();
    }
 
    [[nodiscard]] bool isEmpty() const noexcept {
        return orders.empty();
    }
 
    [[nodiscard]] Order* getBestOrder() noexcept {
        return orders.empty() ? nullptr : orders.front();
    }
 
    [[nodiscard]] const Order* getBestOrder() const noexcept {
        return orders.empty() ? nullptr : orders.front();
    }
 
    void insertOrder(Order* order) noexcept {
        // Insert in priority order (lower priority value = higher priority)
        auto it = orders.begin();
        while (it != orders.end() && it->priority <= order->priority) {
            ++it;
        }
 
        if (it == orders.end()) {
            orders.push_back(order);
        } else {
            orders.insert_before(&(*it), order);
        }
 
        total_quantity += order->quantity;
    }
 
    void removeOrder(Order* order) noexcept {
        total_quantity -= order->quantity;
        orders.erase(order);
    }
 
    void updateOrderQuantity(Quantity old_quantity, Quantity new_quantity) noexcept {
        total_quantity = total_quantity - old_quantity + new_quantity;
    }
 
    [[nodiscard]] constexpr bool operator==(const PriceLevelL3& other) const noexcept {
        return price == other.price;
    }
 
    [[nodiscard]] constexpr bool operator!=(const PriceLevelL3& other) const noexcept {
        return price != other.price;
    }
 
    [[nodiscard]] constexpr bool operator<(const PriceLevelL3& other) const noexcept {
        return price < other.price;
    }
 
    [[nodiscard]] constexpr bool operator>(const PriceLevelL3& other) const noexcept {
        return price > other.price;
    }
};
 
struct BidComparatorL3 {
    [[nodiscard]] constexpr bool operator()(const PriceLevelL3& a, const PriceLevelL3& b) const noexcept {
        return a.price > b.price;   // Descending: highest bid first
    }
 
    [[nodiscard]] constexpr bool operator()(Price a, const PriceLevelL3& b) const noexcept {
        return a > b.price;
    }
 
    [[nodiscard]] constexpr bool operator()(const PriceLevelL3& a, Price b) const noexcept {
        return a.price > b;
    }
 
    [[nodiscard]] constexpr bool operator()(Price a, Price b) const noexcept {
        return a > b;
    }
};
 
struct AskComparatorL3 {
    [[nodiscard]] constexpr bool operator()(const PriceLevelL3& a, const PriceLevelL3& b) const noexcept {
        return a.price < b.price;  // Ascending: lowest ask first
    }
 
    [[nodiscard]] constexpr bool operator()(Price a, const PriceLevelL3& b) const noexcept {
        return a < b.price;
    }
 
    [[nodiscard]] constexpr bool operator()(const PriceLevelL3& a, Price b) const noexcept {
        return a.price < b;
    }
 
    [[nodiscard]] constexpr bool operator()(Price a, Price b) const noexcept {
        return a < b;
    }
};
 
SLICK_DETAIL_NAMESPACE_END