order_map.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/order.hpp>
#include <unordered_map>
 
SLICK_DETAIL_NAMESPACE_BEGIN
 
class OrderMap {
public:
    using MapType = std::unordered_map<OrderId, Order*>;
    using iterator = MapType::iterator;
    using const_iterator = MapType::const_iterator;
 
    explicit OrderMap(std::size_t initial_capacity = 1024) {
        map_.reserve(initial_capacity);
    }
 
    bool insert(Order* order) noexcept {
        SLICK_ASSERT(order != nullptr);
        // Avoid structured bindings to work around C++23 tuple conversion issues with Clang 17 + GCC 14 libstdc++
        auto result = map_.try_emplace(order->order_id, order);
        return result.second;
    }
 
    bool erase(OrderId order_id) noexcept {
        return map_.erase(order_id) > 0;
    }
 
    [[nodiscard]] Order* find(OrderId order_id) noexcept {
        auto it = map_.find(order_id);
        return (it != map_.end()) ? it->second : nullptr;
    }
 
    [[nodiscard]] const Order* find(OrderId order_id) const noexcept {
        auto it = map_.find(order_id);
        return (it != map_.end()) ? it->second : nullptr;
    }
 
    [[nodiscard]] bool contains(OrderId order_id) const noexcept {
        return map_.contains(order_id);
    }
 
    [[nodiscard]] std::size_t size() const noexcept {
        return map_.size();
    }
 
    [[nodiscard]] bool empty() const noexcept {
        return map_.empty();
    }
 
    void reserve(std::size_t capacity) {
        map_.reserve(capacity);
    }
 
    void clear() noexcept {
        map_.clear();
    }
 
    [[nodiscard]] iterator begin() noexcept { return map_.begin(); }
    [[nodiscard]] iterator end() noexcept { return map_.end(); }
    [[nodiscard]] const_iterator begin() const noexcept { return map_.begin(); }
    [[nodiscard]] const_iterator end() const noexcept { return map_.end(); }
    [[nodiscard]] const_iterator cbegin() const noexcept { return map_.cbegin(); }
    [[nodiscard]] const_iterator cend() const noexcept { return map_.cend(); }
 
private:
    MapType map_;  // OrderId -> Order* mapping
};
 
SLICK_DETAIL_NAMESPACE_END