orderbook_manager.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/orderbook_l2.hpp>
#include <slick/orderbook/orderbook_l3.hpp>
#include <slick/orderbook/detail/flat_map.hpp>
#include <memory>
#include <shared_mutex>
#include <string>
#include <vector>
#include <mutex>
#include <utility>
 
SLICK_NAMESPACE_BEGIN
 
template<typename OrderBookT>
class OrderBookManager {
public:
    using OrderBookPtr = std::shared_ptr<OrderBookT>;
    using SymbolMap = detail::FlatMap<SymbolId, OrderBookPtr>;
 
    explicit OrderBookManager(std::size_t initial_symbol_capacity = 64);
 
    ~OrderBookManager() = default;
 
    // Non-copyable, movable (manual implementation: std::shared_mutex is neither copyable nor movable)
    // Moving transfers the orderbooks under the source's lock; the moved-from manager is left empty.
    // Lifetime on move:
    // - Orderbooks of the source are transferred, not copied: pointers/handles obtained from the
    //   source stay valid and now refer to orderbooks owned by the destination.
    // - Move assignment releases the destination's previous orderbooks, as clear() does: raw pointers
    //   obtained from the destination before the assignment are invalidated, unless a shared handle
    //   (getSharedOrderBook()/getOrCreateSharedOrderBook()) still retains that orderbook.
    OrderBookManager(const OrderBookManager&) = delete;
    OrderBookManager& operator=(const OrderBookManager&) = delete;
    OrderBookManager(OrderBookManager&& other) noexcept;
    OrderBookManager& operator=(OrderBookManager&& other) noexcept;
 
    [[nodiscard]] OrderBookT* getOrCreateOrderBook(SymbolId symbol);
 
    [[nodiscard]] const OrderBookT* getOrderBook(SymbolId symbol) const;
 
    [[nodiscard]] OrderBookT* getOrderBook(SymbolId symbol);
 
    [[nodiscard]] std::shared_ptr<OrderBookT> getOrCreateSharedOrderBook(SymbolId symbol);
 
    [[nodiscard]] std::shared_ptr<OrderBookT> getSharedOrderBook(SymbolId symbol) const;
 
    [[nodiscard]] bool hasSymbol(SymbolId symbol) const;
 
    bool removeOrderBook(SymbolId symbol);
 
    [[nodiscard]] std::vector<SymbolId> getSymbols() const;
 
    [[nodiscard]] std::size_t symbolCount() const;
 
    void clear();
 
    void reserve(std::size_t capacity);
 
private:
    template<typename Projection>
    auto find(SymbolId symbol, Projection&& proj) const;
 
    template<typename Projection>
    auto findOrCreate(SymbolId symbol, Projection&& proj);
 
    mutable std::shared_mutex mutex_;  
    SymbolMap symbol_map_;             
};
 
SLICK_NAMESPACE_END
 
// Include implementation for header-only mode
#ifdef SLICK_ORDERBOOK_HEADER_ONLY
#include <slick/orderbook/detail/impl/orderbook_manager_impl.hpp>
#elif SLICK_EXTERN_TEMPLATE_DECLS
// Explicitly instantiated in the compiled library (src/core/orderbook_manager.cpp)
SLICK_NAMESPACE_BEGIN
SLICK_DLL_INTERFACE_WARNINGS_PUSH
extern template class SLICK_API OrderBookManager<OrderBookL2>;
extern template class SLICK_API OrderBookManager<OrderBookL3>;
SLICK_DLL_INTERFACE_WARNINGS_POP
SLICK_NAMESPACE_END
#endif