eventDefinitions.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_EVENTDEFINITIONS_HPP
#define RTCTK_COMPONENTFRAMEWORK_EVENTDEFINITIONS_HPP
 
#include <rtctk/componentFramework/jsonPayload.hpp>
#include <rtctk/componentFramework/timeString.hpp>
 
#include <boost/core/demangle.hpp>
 
#include <chrono>
#include <set>
 
namespace rtctk::componentFramework {
// Suppressing warnings about duplicate ToJson methods. We are not using polymorphism on purpose.
// cppcheck-suppress-begin duplInheritedMember
 
template <typename T>
std::string PrettyTypeName() {
    return boost::core::demangle((typeid(T).name()));
}
 
template <typename EventType>
bool ConvertibleTo(const JsonPayload& j) {
    if (j.contains("type")) {
        if (j.at("type").get<std::set<std::string>>().contains(PrettyTypeName<EventType>())) {
            return true;
        }
    }
    return false;
}
 
template <typename EventType>
std::optional<EventType> ConvertTo(const JsonPayload& j) {
    if (ConvertibleTo<EventType>(j)) {
        EventType e;
        from_json(j, e);
        return e;
    }
    return {};
}
 
 
struct AbstractEvent {
    AbstractEvent() = default;
 
    virtual ~AbstractEvent() = default;
 
    explicit AbstractEvent(const std::string& origin);
 
    AbstractEvent(const std::string& origin, const TimeString& time);
 
    [[deprecated("Use from_json instead.")]]
    explicit AbstractEvent(const JsonPayload& j);
 
    [[deprecated("Use to_json instead.")]]
    JsonPayload ToJson() const;
 
    std::string origin;  // from which srtc-component does the event come from
    TimeString time;     // when was event created
};
 
// The function names below do not follow our conventions. However, these names are required by the
// nlohmann/json.hpp API. Therefore the linter warnings are being suppressed. This is applicable to
// all subsequent to_json/from_json functions in this file.
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const AbstractEvent& e);
void from_json(const JsonPayload& j, AbstractEvent& e);
// NOLINTEND(readability-identifier-naming)
 
 
struct ComputationEvent : AbstractEvent {
    inline static const std::string TOPIC_NAME = "computation_topic";
 
    ComputationEvent() = default;
 
    ComputationEvent(const std::string& origin, const std::string& item, const std::string& state);
 
    ComputationEvent(const std::string& origin, const std::string& item);
 
    [[deprecated("Use from_json instead.")]]
    explicit ComputationEvent(const JsonPayload& j);
 
    [[deprecated("Use to_json instead.")]]
    JsonPayload ToJson() const;
 
    std::string item;   // what was computed
    std::string state;  // was computaton started, finished, failed
};
 
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const ComputationEvent& e);
void from_json(const JsonPayload& j, ComputationEvent& e);
// NOLINTEND(readability-identifier-naming)
 
 
struct ComputationStartedEvent : ComputationEvent {
    ComputationStartedEvent() = default;
 
    ComputationStartedEvent(const std::string& origin, const std::string& item);
 
    [[deprecated("Use from_json instead.")]]
    explicit ComputationStartedEvent(const JsonPayload& j);
 
    [[deprecated("Use to_json instead.")]]
    JsonPayload ToJson() const;
};
 
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const ComputationStartedEvent& e);
void from_json(const JsonPayload& j, ComputationStartedEvent& e);
// NOLINTEND(readability-identifier-naming)
 
 
struct ComputationFinishedEvent : ComputationEvent {
    ComputationFinishedEvent() = default;
 
    ComputationFinishedEvent(const std::string& origin,
                             const std::string& item,
                             const JsonPayload& result = nullptr);
 
    [[deprecated("Use from_json instead.")]]
    explicit ComputationFinishedEvent(const JsonPayload& j);
 
    [[deprecated("Use to_json instead.")]]
    JsonPayload ToJson() const;
 
    JsonPayload result;  // result of the computation
};
 
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const ComputationFinishedEvent& e);
void from_json(const JsonPayload& j, ComputationFinishedEvent& e);
// NOLINTEND(readability-identifier-naming)
 
 
struct ConfigurationEvent : AbstractEvent {
    inline static const std::string TOPIC_NAME = "configuration_topic";
 
    struct Item {
        std::string name;
 
        std::optional<TimeString> timestamp;
 
        std::optional<uint64_t> sequence_id;
 
        bool operator==(const Item&) const = default;
    };
 
    using ItemList = std::vector<Item>;
 
    ConfigurationEvent() = default;
 
    ConfigurationEvent(const std::string& origin, const Item& item, const std::string& state);
 
    ConfigurationEvent(const std::string& origin,
                       const ItemList& item,
                       const std::string& state);
 
    ConfigurationEvent(const std::string& origin,
                       const std::string& item,
                       const std::string& state);
 
    ConfigurationEvent(const std::string& origin,
                       const std::vector<std::string>& items,
                       const std::string& state);
 
    [[deprecated("Use from_json instead.")]]
    explicit ConfigurationEvent(const JsonPayload& j);
 
    [[deprecated("Use to_json instead.")]]
    JsonPayload ToJson() const;
 
    ItemList items;  // what was configured
    std::string state;   // was configuration scheduled, started, finished, failed
};
 
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const ConfigurationEvent& e);
void from_json(const JsonPayload& j, ConfigurationEvent& e);
// NOLINTEND(readability-identifier-naming)
 
 
struct ConfigurationUpdatedEvent : ConfigurationEvent {
    ConfigurationUpdatedEvent() = default;
 
    ConfigurationUpdatedEvent(const std::string& origin, const Item& item);
 
    ConfigurationUpdatedEvent(const std::string& origin, const ItemList& items);
 
    ConfigurationUpdatedEvent(const std::string& origin, const std::string& item);
 
    ConfigurationUpdatedEvent(const std::string& origin, const std::vector<std::string>& items);
 
    [[deprecated("Use from_json instead.")]]
    explicit ConfigurationUpdatedEvent(const JsonPayload& j);
 
    [[deprecated("Use to_json instead.")]]
    JsonPayload ToJson() const;
};
 
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const ConfigurationUpdatedEvent& e);
void from_json(const JsonPayload& j, ConfigurationUpdatedEvent& e);
// NOLINTEND(readability-identifier-naming)
 
 
struct ConfigurationRetrievedEvent : ConfigurationEvent {
    ConfigurationRetrievedEvent() = default;
 
    ConfigurationRetrievedEvent(const std::string& origin, const Item& item);
 
    ConfigurationRetrievedEvent(const std::string& origin, const ItemList& items);
 
    ConfigurationRetrievedEvent(const std::string& origin, const std::string& item);
 
    ConfigurationRetrievedEvent(const std::string& origin, const std::vector<std::string>& items);
 
    [[deprecated("Use from_json instead.")]]
    explicit ConfigurationRetrievedEvent(const JsonPayload& j);
 
    [[deprecated("Use to_json instead.")]]
    JsonPayload ToJson() const;
};
 
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const ConfigurationRetrievedEvent& e);
void from_json(const JsonPayload& j, ConfigurationRetrievedEvent& e);
// NOLINTEND(readability-identifier-naming)
 
 
struct HrtcConfigurationScheduledEvent : ConfigurationEvent {
    HrtcConfigurationScheduledEvent() = default;
 
    HrtcConfigurationScheduledEvent(const std::string& origin,
                                    const Item& item,
                                    const std::string& hrtc_origin,
                                    const TimeString& hrtc_timestamp,
                                    uint64_t hrtc_sample_id);
 
    HrtcConfigurationScheduledEvent(const std::string& origin,
                                    const ItemList& items,
                                    const std::string& hrtc_origin,
                                    const TimeString& hrtc_timestamp,
                                    uint64_t hrtc_sample_id);
 
    [[deprecated("Use ctor with Item and TimeString instead.")]]
    HrtcConfigurationScheduledEvent(const std::string& origin,
                                    const std::string& item,
                                    const std::string& hrtc_origin,
                                    uint64_t hrtc_timestamp,
                                    uint64_t hrtc_sample_id);
 
    [[deprecated("Use from_json instead.")]]
    explicit HrtcConfigurationScheduledEvent(const JsonPayload& j);
 
    [[deprecated("Use to_json instead.")]]
    JsonPayload ToJson() const;
 
    std::string hrtc_origin;    // from which hrtc instance, or functional unit within instance
    TimeString hrtc_timestamp;  // scheduled to be applied at which timestamp
    uint64_t hrtc_sample_id;    // scheduled to be applied at which sample_id
};
 
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const HrtcConfigurationScheduledEvent& e);
void from_json(const JsonPayload& j, HrtcConfigurationScheduledEvent& e);
// NOLINTEND(readability-identifier-naming)
 
 
struct HrtcConfigurationAppliedEvent : ConfigurationEvent {
    HrtcConfigurationAppliedEvent() = default;
 
    HrtcConfigurationAppliedEvent(const std::string& origin,
                                  const Item& item,
                                  const std::string& hrtc_origin,
                                  const TimeString& hrtc_timestamp,
                                  uint64_t hrtc_sample_id);
 
    HrtcConfigurationAppliedEvent(const std::string& origin,
                                  const ItemList& items,
                                  const std::string& hrtc_origin,
                                  const TimeString& hrtc_timestamp,
                                  uint64_t hrtc_sample_id);
 
    [[deprecated("Use ctor with Item and TimeString instead.")]]
    HrtcConfigurationAppliedEvent(const std::string& origin,
                                  const std::string& item,
                                  const std::string& hrtc_origin,
                                  uint64_t hrtc_timestamp,
                                  uint64_t hrtc_sample_id);
 
    [[deprecated("Use from_json instead.")]]
    explicit HrtcConfigurationAppliedEvent(const JsonPayload& j);
 
    [[deprecated("Use to_json instead.")]]
    JsonPayload ToJson() const;
 
    std::string hrtc_origin;    // from which hrtc instance, or functional unit within instance
    TimeString hrtc_timestamp;  // applied at which timestamp
    uint64_t hrtc_sample_id;    // applied at which sample_id
};
 
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const HrtcConfigurationAppliedEvent& e);
void from_json(const JsonPayload& j, HrtcConfigurationAppliedEvent& e);
// NOLINTEND(readability-identifier-naming)
 
 
struct CoordinationEvent : AbstractEvent {
    inline static const std::string TOPIC_NAME = "coordination_topic";
 
    CoordinationEvent() = default;
 
    explicit CoordinationEvent(const std::string& origin);
 
    [[deprecated("Use from_json instead.")]]
    explicit CoordinationEvent(const JsonPayload& j);
 
    [[deprecated("Use to_json instead.")]]
    JsonPayload ToJson() const;
};
 
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const CoordinationEvent& e);
void from_json(const JsonPayload& j, CoordinationEvent& e);
// NOLINTEND(readability-identifier-naming)
 
 
struct StateChangedEvent : CoordinationEvent {
    StateChangedEvent() = default;
 
    StateChangedEvent(const std::string& origin,
                      const std::string& entity,
                      const std::string& state);
 
    StateChangedEvent(const std::string& origin, const std::string& state);
 
    [[deprecated("Use from_json instead.")]]
    explicit StateChangedEvent(const JsonPayload& j);
 
    [[deprecated("Use to_json instead.")]]
    JsonPayload ToJson() const;
 
    std::string entity;  // name of the functional entity that changed its state
    std::string state;   // the actual state
};
 
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const StateChangedEvent& e);
void from_json(const JsonPayload& j, StateChangedEvent& e);
// NOLINTEND(readability-identifier-naming)
 
 
struct HrtcStateChangedEvent : StateChangedEvent {
    HrtcStateChangedEvent() = default;
 
    HrtcStateChangedEvent(const std::string& origin,
                          const std::string& hrtc_entity,
                          const std::string& hrtc_state,
                          const TimeString& hrtc_timestamp,
                          uint64_t hrtc_sample_id);
 
    [[deprecated("Use from_json instead.")]]
    explicit HrtcStateChangedEvent(const JsonPayload& j);
 
    [[deprecated("Use to_json instead.")]]
    JsonPayload ToJson() const;
 
    TimeString hrtc_timestamp;  // when did the state change
    uint64_t hrtc_sample_id;    // at which sample_id did the state change
};
 
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const HrtcStateChangedEvent& e);
void from_json(const JsonPayload& j, HrtcStateChangedEvent& e);
// NOLINTEND(readability-identifier-naming)
 
 
struct AlertStatusEvent : AbstractEvent {
    AlertStatusEvent() = default;
 
    // cppcheck-suppress unusedStructMember
    inline static const std::string TOPIC_NAME = "alert_status_topic";
 
    struct Alert {
        std::string origin;
 
        std::string id;
 
        std::string description;
 
        TimeString since;
    };
 
    AlertStatusEvent(bool st, std::vector<Alert> ac, const std::string& origin);
 
    bool status;
 
    std::vector<Alert> active_alerts;
};
 
// NOLINTBEGIN(readability-identifier-naming)
void to_json(JsonPayload& j, const AlertStatusEvent& e);
void from_json(const JsonPayload& j, AlertStatusEvent& e);
// NOLINTEND(readability-identifier-naming)
 
// cppcheck-suppress-end duplInheritedMember
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_EVENTDEFINITIONS_HPP