IModelEvents.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <QList>
#include <QMetaObject>
#include <QMetaType>
#include <QObject>
#include <QString>
#include <QUuid>
#include <functional>
#include <utility>
#include <variant>
 
#define OPENSWMM_MODEL_EVENTS_IID "io.opensimulator.openswmm.IEventSource/1.0"
 
namespace OpenSWMM::Sdk
{
inline constexpr auto MODEL_EVENTS_IID = OPENSWMM_MODEL_EVENTS_IID;
 
enum class EventKind : quint32 {
    InstanceDiscovered =
        1,               
    InstanceClosing = 2, 
    InstanceActivated =
        3, 
    SelectionChanged = 4, 
    ModelEdited = 5,      
    AttributesChanged =
        6, 
    ViewportChanged = 7, 
    LayersChanged =
        8, 
    BoundaryChanged = 9, 
    ActiveResultsChanged =
        10,               
    RunsChanged = 11,     
    SettingsChanged = 12, 
    ThemeChanged = 13,    
    JobProgress = 14,     
    JobFinished = 15      
};
 
struct ModelEvent {
    QUuid instanceId; 
    QString
        objectName; 
};
 
struct SpatialEvent {
    QUuid instanceId; 
    QString layerId; 
};
 
struct ResultsEvent {
    QUuid instanceId; 
};
 
struct RunsEvent {
};
 
struct SettingsEvent {
    QString key; 
};
 
struct ThemeEvent {
};
 
struct JobProgressEvent {
    QString title;        
    double progress = 0.; 
    QString text;         
};
 
struct JobFinishedEvent {
    QString title; 
    bool ok =
        false; 
    QString error; 
};
 
using EventPayload = std::variant<ModelEvent, SpatialEvent, ResultsEvent, RunsEvent, SettingsEvent,
                                  ThemeEvent, JobProgressEvent, JobFinishedEvent>;
 
struct Event {
    EventKind kind = EventKind::
        InstanceDiscovered; 
    quint64 sequence =
        0; 
    EventPayload payload; 
 
    [[nodiscard]] QUuid instanceId() const
    {
        if (const auto *value = std::get_if<ModelEvent>(&payload))
            return value->instanceId;
        if (const auto *value = std::get_if<SpatialEvent>(&payload))
            return value->instanceId;
        if (const auto *value = std::get_if<ResultsEvent>(&payload))
            return value->instanceId;
        return {};
    }
};
 
struct EventFilter {
    QList<EventKind> kinds; 
    QUuid instanceId;       
 
    [[nodiscard]] bool accepts(const Event &event) const
    {
        return (kinds.isEmpty() || kinds.contains(event.kind)) &&
               (instanceId.isNull() || instanceId == event.instanceId());
    }
};
 
class IModelEvents
{
public:
    virtual ~IModelEvents() = default;
 
    virtual QMetaObject::Connection subscribe(QObject *context, const EventFilter &filter,
                                              std::function<void(const Event &)> callback) = 0;
};
 
class ScopedEventSubscription
{
public:
    ScopedEventSubscription() = default;
    explicit ScopedEventSubscription(QMetaObject::Connection connection)
        : mConnection(std::move(connection))
    {
    }
    ~ScopedEventSubscription() { reset(); }
    ScopedEventSubscription(const ScopedEventSubscription &other) = delete;
    ScopedEventSubscription &operator=(const ScopedEventSubscription &other) = delete;
    ScopedEventSubscription(ScopedEventSubscription &&other) noexcept
        : mConnection(std::exchange(other.mConnection, {}))
    {
    }
    ScopedEventSubscription &operator=(ScopedEventSubscription &&other) noexcept
    {
        if (this != &other)
            reset(std::exchange(other.mConnection, {}));
        return *this;
    }
    void reset(QMetaObject::Connection connection = {})
    {
        QObject::disconnect(mConnection);
        mConnection = std::move(connection);
    }
    [[nodiscard]] bool isConnected() const { return static_cast<bool>(mConnection); }
 
private:
    QMetaObject::Connection mConnection; 
};
}
 
Q_DECLARE_INTERFACE(OpenSWMM::Sdk::IModelEvents, OPENSWMM_MODEL_EVENTS_IID)
Q_DECLARE_METATYPE(OpenSWMM::Sdk::EventKind)
Q_DECLARE_METATYPE(OpenSWMM::Sdk::ModelEvent)
Q_DECLARE_METATYPE(OpenSWMM::Sdk::SpatialEvent)
Q_DECLARE_METATYPE(OpenSWMM::Sdk::ResultsEvent)
Q_DECLARE_METATYPE(OpenSWMM::Sdk::RunsEvent)
Q_DECLARE_METATYPE(OpenSWMM::Sdk::SettingsEvent)
Q_DECLARE_METATYPE(OpenSWMM::Sdk::ThemeEvent)
Q_DECLARE_METATYPE(OpenSWMM::Sdk::JobProgressEvent)
Q_DECLARE_METATYPE(OpenSWMM::Sdk::JobFinishedEvent)
Q_DECLARE_METATYPE(OpenSWMM::Sdk::Event)