alertServiceIf.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_ALERTSERVICEIF_HPP
#define RTCTK_COMPONENTFRAMEWORK_ALERTSERVICEIF_HPP
#include <iosfwd>
#include <string>
#include <sys/types.h>
 
#include <boost/signals2/signal.hpp>
 
#include <rtctk/componentFramework/exceptions.hpp>
 
namespace rtctk::componentFramework {
 
class AlertConflictException : public RtctkException {
    using RtctkException::RtctkException;
};
 
class AlertSource {
public:
    AlertSource();
 
    ~AlertSource() noexcept;
 
    AlertSource(AlertSource&& other) noexcept;
 
    AlertSource& operator=(AlertSource&& other) noexcept;
 
    using TimePoint = std::chrono::system_clock::time_point;
 
    void Reset() {
        Set(false);
    }
 
    void Set(bool state = true);
 
    bool IsSet() const noexcept {
        return m_state;
    }
 
    std::pair<bool, TimePoint> GetStatus() const noexcept {
        return {m_state, m_since};
    }
 
    using Signal = boost::signals2::signal<void(bool, TimePoint)>;
 
    boost::signals2::connection Connect(Signal::slot_type const& slot);
 
private:
    bool m_state;
    TimePoint m_since;
    Signal m_signal;
};
 
class AlertDescription {
public:
    explicit AlertDescription(std::string id, std::string description) noexcept;
 
    std::string const& GetId() const noexcept {
        return m_id;
    }
 
    std::string const& GetDescription() const noexcept {
        return m_description;
    }
 
private:
    std::string m_id;
    std::string m_description;
};
 
class AlertSourceFactoryIf {
public:
    virtual ~AlertSourceFactoryIf() noexcept = default;
    [[nodiscard]] virtual AlertSource MakeAlertSource(AlertDescription const& description) = 0;
};
 
class AlertStatusObserverIf {
public:
    virtual ~AlertStatusObserverIf() noexcept = default;
 
    using ReducedStatus = std::optional<bool>;
 
    using TimePoint = std::chrono::system_clock::time_point;
 
    struct AlertStatus {
        bool status;
 
        TimePoint since;
 
        AlertDescription description;
    };
 
 
    using ReducedStatusSignal =
        boost::signals2::signal<void(ReducedStatus const&, std::vector<AlertStatus> const&)>;
 
    virtual boost::signals2::connection
    ConnectReducedStatus(ReducedStatusSignal::slot_type slot) = 0;
 
 
    [[nodiscard]] virtual ReducedStatus GetReducedStatus() const = 0;
 
    [[nodiscard]] virtual std::vector<AlertStatus> GetAlertStatuses() const = 0;
};
 
class AlertServiceIf : public AlertStatusObserverIf, public AlertSourceFactoryIf {
public:
    using AlertStatus = AlertStatusObserverIf::AlertStatus;
    virtual ~AlertServiceIf() noexcept = default;
};
 
std::ostream& operator<<(std::ostream& os, AlertServiceIf::AlertStatus const& status);
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_ALERTSERVICEIF_HPP