EventBus.hxx

См. документацию.

#pragma once
 
#include "Event.hxx"
#include "IObserver.hxx"
#include "ISubject.hxx"
#include <algorithm>
#include <vector>
#include <memory>
#include <mutex>

namespace svcs::services {

namespace ConsoleColor {
    const std::string RESET = "\033[0m";
    const std::string BLACK = "\033[30m";
    const std::string RED = "\033[31m";
    const std::string GREEN = "\033[32m";
    const std::string YELLOW = "\033[33m";
    const std::string BLUE = "\033[34m";
    const std::string MAGENTA = "\033[35m";
    const std::string CYAN = "\033[36m";
    const std::string WHITE = "\033[37m";
    const std::string BRIGHT_RED = "\033[91m";
    const std::string BRIGHT_GREEN = "\033[92m";
    const std::string BRIGHT_YELLOW = "\033[93m";
    const std::string BRIGHT_BLUE = "\033[94m";
    const std::string BRIGHT_MAGENTA = "\033[95m";
    const std::string BRIGHT_CYAN = "\033[96m";
    const std::string BRIGHT_WHITE = "\033[97m";
 
    const std::string BOLD = "\033[1m";
    const std::string DIM = "\033[2m";
    const std::string ITALIC = "\033[3m";
    const std::string UNDERLINE = "\033[4m";
}

class EventBus : public ISubject, public std::enable_shared_from_this<EventBus> {
private:
    std::vector<std::weak_ptr<IObserver>> observers_;

    mutable std::mutex observers_mutex_;

    static std::string getEventColor(Event::Type type) {
        switch (type) {
            case Event::REPOSITORY_INIT_SUCCESS:
                return ConsoleColor::BRIGHT_GREEN;
            case Event::SAVE_SUCCESS:
                return ConsoleColor::BRIGHT_GREEN;
            case Event::ERROR_MESSAGE:
                return ConsoleColor::BRIGHT_RED;
            case Event::WARNING_MESSAGE:
                return ConsoleColor::BRIGHT_YELLOW;
            case Event::GENERAL_INFO:
                return ConsoleColor::BRIGHT_CYAN;
            case Event::DEBUG_MESSAGE:
                return ConsoleColor::BRIGHT_BLUE;
            case Event::HELP_MESSAGE:
                return ConsoleColor::GREEN;
            case Event::PROTOCOL_START:
                return ConsoleColor::BRIGHT_MAGENTA;
            case Event::PROTOCOL_SUCCESS:
                return ConsoleColor::BRIGHT_GREEN;
            case Event::PROTOCOL_ERROR:
                return ConsoleColor::BRIGHT_RED;
            case Event::NETWORK_SEND:
                return ConsoleColor::BRIGHT_CYAN;
            case Event::NETWORK_RECEIVE:
                return ConsoleColor::BRIGHT_BLUE;
            case Event::OBJECT_TRANSFER:
                return ConsoleColor::BRIGHT_YELLOW;
            case Event::REFERENCE_UPDATE:
                return ConsoleColor::BRIGHT_GREEN;
            case Event::NEGOTIATION_PHASE:
                return ConsoleColor::BRIGHT_MAGENTA;
            default:
                return ConsoleColor::WHITE;
        }
    }

     */
    static std::string getEventIcon(Event::Type type) {
        switch (type) {
            case Event::REPOSITORY_INIT_SUCCESS:
                return "✅";
            case Event::SAVE_SUCCESS:
                return "💾";
            case Event::ERROR_MESSAGE:
                return "❌";
            case Event::WARNING_MESSAGE:
                return "⚠️ ";
            case Event::GENERAL_INFO:
                return "ℹ️ ";
            case Event::DEBUG_MESSAGE:
                return "🐛";
            case Event::HELP_MESSAGE:
                return "💡";
            case Event::PROTOCOL_START:
                return "🚀";
            case Event::PROTOCOL_SUCCESS:
                return "✅";
            case Event::PROTOCOL_ERROR:
                return "💥";
            case Event::NETWORK_SEND:
                return "📤";
            case Event::NETWORK_RECEIVE:
                return "📥";
            case Event::OBJECT_TRANSFER:
                return "📦";
            case Event::REFERENCE_UPDATE:
                return "🔗";
            case Event::NEGOTIATION_PHASE:
                return "🤝";
            default:
                return "";
        }
    }
 
public:
    ~EventBus() override = default;

    void attach(std::shared_ptr<IObserver> observer) override {
        std::lock_guard<std::mutex> lock(observers_mutex_);
        observers_.push_back(observer);
    }

    void detach(std::shared_ptr<IObserver> observer_to_remove) override {
        std::lock_guard<std::mutex> lock(observers_mutex_);
 
        auto it = std::remove_if(observers_.begin(), observers_.end(),
            [&](const std::weak_ptr<IObserver>& weak_obs) {
                auto shared_obs = weak_obs.lock();
                return shared_obs && (shared_obs == observer_to_remove);
            }
        );
        observers_.erase(it, observers_.end());
    }

    void notify(const Event& event) const override {
        std::string color = getEventColor(event.type);
        std::string icon = getEventIcon(event.type);
        std::string sourceColor = ConsoleColor::DIM + ConsoleColor::BLACK;
 
        // Format message with colors
        std::string formattedMessage = color + icon + " " + event.details +
                                      sourceColor + " [" + event.source_name + "]" +
                                      ConsoleColor::RESET;
 
        // Create event copy with formatted message
        Event coloredEvent = event;
        coloredEvent.details = formattedMessage;
 
        for (auto& observer : observers_) {
            observer.lock()->update(coloredEvent);
        }
    }
};
 
}