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);
 
    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);
 
    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);
};
 
// 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);
 
    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);
 
    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);
};
 
// 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);
};
 
// 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);
 
    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);
 
    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);
};
 
// 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);
 
    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);
 
    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