eventLog.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_common_libdaq
 * @copyright 2022 ESO - European Southern Observatory
 *
 * @brief Contains declaration for EventLog, ObservableEventLog and related events.
 */
#ifndef OCM_DAQ_DAQ_EVENT_HPP_
#define OCM_DAQ_DAQ_EVENT_HPP_
 
#include <chrono>
#include <string>
#include <vector>
#include <variant>
#include <iosfwd>
 
#include <boost/signals2/signal.hpp>
 
#include "status.hpp"
 
 
namespace daq {
 
/**
 * Represents a generic event if a more specific event is not usable.
 *
 * @ingroup daq_common_libdaq
 */
struct GenericEvent {
    using TimePoint = std::chrono::time_point<std::chrono::steady_clock>;
 
    GenericEvent(std::string id, std::string description, std::optional<Status> status) noexcept;
 
    GenericEvent(GenericEvent&&) = default;
    GenericEvent(GenericEvent const&) = default;
    GenericEvent& operator=(GenericEvent&&) = default;
    GenericEvent& operator=(GenericEvent const&) = default;
 
    bool operator==(GenericEvent const& rhs) const noexcept;
    bool operator!=(GenericEvent const& rhs) const noexcept;
 
    TimePoint timestamp;
    std::string id;
    std::string description;
    std::optional<Status> status;
};
 
std::ostream& operator<<(std::ostream& os, GenericEvent const& s);
 
 
/**
 * Event related to an action being requested or performed.
 *
 * @ingroup daq_common_libdaq
 */
struct ActionEvent : GenericEvent {
    using GenericEvent::GenericEvent;
};
 
/**
 * Event directly related to user action, such as a command to do something.
 *
 * @ingroup daq_common_libdaq
 */
struct UserActionEvent : ActionEvent {
    using ActionEvent::ActionEvent;
};
 
struct ErrorEvent final : GenericEvent {
    ErrorEvent(std::string id,
               std::string description,
               std::optional<Status> status,
               std::string origin) noexcept;
    bool operator==(ErrorEvent const& rhs) const noexcept;
    bool operator!=(ErrorEvent const& rhs) const noexcept;
    /**
     * Error origin.
     */
    std::string origin;
};
std::ostream& operator<<(std::ostream& os, ErrorEvent const& s);
 
 
/**
 * Represents a collection of events.
 *
 * @ingroup daq_common_libdaq
 */
struct EventLog {
    using EventType = std::variant<ActionEvent, UserActionEvent, GenericEvent, ErrorEvent>;
    using TimePoint = std::chrono::time_point<std::chrono::steady_clock>;
 
    bool operator==(EventLog const& rhs) const noexcept;
    bool operator!=(EventLog const& rhs) const noexcept;
 
    std::vector<EventType> events;
};
 
 
/**
 * Stores data acquisition status and allows subscription to status changes.
 *
 * DaqController and other objects will update ObservableEvent as changes occur.
 *
 * @ingroup daq_common_libdaq
 */
class ObservableEventLog {
  public:
    using Signal = boost::signals2::signal<void(EventLog::EventType const&)>;
 
    /**
     * Construct a new object
     *
     * @param id Data acquisition identifier.
     */
    explicit ObservableEventLog() = default;
    ObservableEventLog(ObservableEventLog const&) = delete;
    ObservableEventLog& operator=(ObservableEventLog const&) = delete;
 
    /** @name Modifiers
     * @{ */
    /**
     * Records that a file has been produced for this data acquisition.
     *
     * @param files Files to add/record.
     *
     * @post Connected observers have been signalled.
     */
    void AddEvent(EventLog::EventType event);
    /**
     * Like AddEvent but emplaces the specified event type.
     */
    template<class T, class... Args>
    void EmplaceEvent(Args&&... args) {
        m_event_log.events.emplace_back(std::in_place_type<T>, std::forward<Args>(args)...);
        m_signal(m_event_log.events.back());
    }
 
    /**
     * Connect observer that is invoked when state is modified.
     *
     * @param o Observer callable invoked on status changes (state or file changes)
     * Observer must be invocable with signature `void(ObservableEvent const&)`.
     *
     * @return signal connection object that can be used to disconnect observer:
     *
     * @code
     * auto c = status.ConnectObserver([](ObservableEvent const& s){});
     * // later the connection object can be used to disconnect
     * c.disconnect();
     * @endcode
     */
    template <class Observer>
    boost::signals2::connection ConnectObserver(Observer o) {
        return m_signal.connect(std::move(o));
    }
    /** @} */
 
    /** @name Accessors
     * @{ */
    /**
     * Allow implicit conversion to non-observable status.
     */
    inline operator EventLog const&() {
        return m_event_log;
    }
 
    inline EventLog const& GetEventLog() const noexcept {
        return m_event_log;
    }
 
    inline std::vector<EventLog::EventType> const& GetEventContainer() const noexcept {
        return m_event_log.events;
    }
    /** @} */
 
  private:
    EventLog m_event_log;
    Signal m_signal;
};
 
}  // namespace daq
#endif  // #ifndef OCM_DAQ_DAQ_EVENT_HPP_