observer.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/events.hpp>
#include <slick/orderbook/concepts.hpp>
#include <algorithm>
#include <vector>
#include <memory>
 
SLICK_NAMESPACE_BEGIN
 
class IOrderBookObserver {
public:
    virtual ~IOrderBookObserver() = default;
 
    virtual void onPriceLevelUpdate([[maybe_unused]] const PriceLevelUpdate& update) {
    }
 
    virtual void onOrderUpdate([[maybe_unused]] const OrderUpdate& update) {
    }
 
    virtual void onTrade([[maybe_unused]] const Trade& trade) {
    }
 
    virtual void onTopOfBookUpdate([[maybe_unused]] const TopOfBook& tob) {
    }
 
    virtual void onSnapshotBegin([[maybe_unused]] SymbolId symbol, [[maybe_unused]] uint64_t seq_num, [[maybe_unused]] Timestamp timestamp) {
    }
 
    virtual void onSnapshotEnd([[maybe_unused]] SymbolId symbol, [[maybe_unused]] uint64_t seq_num, [[maybe_unused]] Timestamp timestamp) {
    }
};
 
class ObserverManager {
public:
    ObserverManager() = default;
    ~ObserverManager() = default;
 
    // Non-copyable, movable
    ObserverManager(const ObserverManager&) = delete;
    ObserverManager& operator=(const ObserverManager&) = delete;
    ObserverManager(ObserverManager&&) noexcept = default;
    ObserverManager& operator=(ObserverManager&&) noexcept = default;
 
    void addObserver(std::shared_ptr<IOrderBookObserver> observer) {
        if (observer) {
            observers_.push_back(std::move(observer));
        }
    }
 
    bool removeObserver(const std::shared_ptr<IOrderBookObserver>& observer) {
        auto it = std::find(observers_.begin(), observers_.end(), observer);
        if (it != observers_.end()) {
            observers_.erase(it);
            return true;
        }
        return false;
    }
 
    void clearObservers() noexcept {
        observers_.clear();
    }
 
    [[nodiscard]] std::size_t observerCount() const noexcept {
        return observers_.size();
    }
 
    void notifyPriceLevelUpdate(const PriceLevelUpdate& update) const {
        for (const auto& observer : observers_) {
            observer->onPriceLevelUpdate(update);
        }
    }
 
    void notifyOrderUpdate(const OrderUpdate& update) const {
        for (const auto& observer : observers_) {
            observer->onOrderUpdate(update);
        }
    }
 
    void notifyTrade(const Trade& trade) const {
        for (const auto& observer : observers_) {
            observer->onTrade(trade);
        }
    }
 
    void notifyTopOfBookUpdate(const TopOfBook& tob) const {
        for (const auto& observer : observers_) {
            observer->onTopOfBookUpdate(tob);
        }
    }
 
    void notifySnapshotBegin(SymbolId symbol, uint64_t seq_num, Timestamp timestamp) const {
        for (const auto& observer : observers_) {
            observer->onSnapshotBegin(symbol, seq_num, timestamp);
        }
    }
 
    void notifySnapshotEnd(SymbolId symbol, uint64_t seq_num, Timestamp timestamp) const {
        for (const auto& observer : observers_) {
            observer->onSnapshotEnd(symbol, seq_num, timestamp);
        }
    }
 
private:
    std::vector<std::shared_ptr<IOrderBookObserver>> observers_;
};
 
SLICK_NAMESPACE_END