status.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libdaq
 * @copyright 2021 ESO - European Southern Observatory
 *
 * @brief Contains declaration for Status and ObservableStatus
 */
#ifndef OCM_DAQ_DAQ_STATUS_HPP_
#define OCM_DAQ_DAQ_STATUS_HPP_
 
#include <chrono>
#include <string>
#include <vector>
#include <iosfwd>
 
#include <boost/signals2/signal.hpp>
 
#include <daq/fits/keyword.hpp>
#include "state.hpp"
#include "dpPart.hpp"
 
 
namespace daq {
 
/**
 * Non observable status object that keeps stores status of data acquisition.
 *
 * It is also planned to be serializable to allow crash recovery from persistent storage.
 *
 * @ingroup daq_ocm_libdaq
 */
struct Status {
    using TimePoint = std::chrono::time_point<std::chrono::steady_clock>;
 
    explicit Status(std::string id) noexcept;
    Status(std::string id,
           State state,
           bool error,
           DpParts files,
           fits::KeywordVector keywords,
           TimePoint timestamp) noexcept;
 
    Status(Status&&) = default;
    Status(Status const&) = default;
    Status& operator=(Status&&) = default;
    Status& operator=(Status const&) = default;
 
    bool operator==(Status const& rhs) const noexcept;
    bool operator!=(Status const& rhs) const noexcept;
 
    std::string id;
    State state;
    bool error;
    DpParts files;
    fits::KeywordVector keywords;
    TimePoint timestamp;
};
 
std::ostream& operator<<(std::ostream& os, Status const& s);
 
/**
 * Stores data acquisition status and allows subscription to status changes.
 *
 * DaqController instances will update ObservableStatus as changes occur.
 *
 * @ingroup daq_ocm_libdaq
 */
class ObservableStatus {
  public:
    /**
     * Construct a new object
     *
     * @param id Data acquisition identifier.
     */
    explicit ObservableStatus(std::string id) noexcept;
    ObservableStatus(ObservableStatus const&) = delete;
    ObservableStatus& operator=(ObservableStatus const&) = delete;
 
    bool operator==(ObservableStatus const& rhs) const noexcept;
    bool operator!=(ObservableStatus const& rhs) const noexcept;
 
    bool operator==(Status const& rhs) const noexcept;
    bool operator!=(Status const& rhs) const noexcept;
 
    ///@name Accessors
    ///@{
    /**
     * @return Data acquisition identifier
     */
    std::string const& GetId() const noexcept;
 
    /**
     * @return Data acquisition state
     */
    State GetState() const noexcept;
 
    /**
     * @return Data acquisition error flag.
     */
    bool GetError() const noexcept;
 
    /**
     * @return Files created for this data acquisition
     */
    std::vector<DpPart> const& GetFiles() const noexcept;
 
    /**
     * @return Primary HDU keywords provided by OCM for this data acquisition
     */
    fits::KeywordVector const& GetKeywords() const noexcept;
 
    ///@}
 
    ///@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 AddFiles(std::vector<DpPart> const& files);
 
    /**
     * Updates (adds or replaces) Primary HDU keywords.
     */
    void UpdateKeywords(fits::KeywordVector const&) noexcept;
 
    /**
     * Set state of data acquisition.
     *
     * @param s New state
     *
     * @post Connected observers have been signalled.
     */
    void SetState(State s) noexcept;
 
    /**
     * Set error flag for data acquisition.
     *
     * @param error New error flag status.
     *
     * @post Connected observers have been signalled.
     */
    void SetError(bool error) noexcept;
 
    /**
     * 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(ObservableStatus const&)`.
     *
     * @return signal connection object that can be used to disconnect observer:
     *
     * @code
     * auto c = status.ConnectObserver([](ObservableStatus const& s){});
     * // later the connection object can be used to disconnect
     * c.disconnect();
     * @endcode
     */
    using Signal = boost::signals2::signal<void(ObservableStatus const&)>;
    template <class Observer>
    boost::signals2::connection ConnectObserver(Observer o) {
        return m_signal.connect(std::move(o));
    }
 
    /**
     * Allow implicit conversion to non-observable status.
     */
    operator Status() const;
    Status const& GetStatus() const noexcept;
 
    ///@}
  private:
    /// Signal changes to observers
    void SignalChanges() noexcept;
 
    Status m_status;
    // const Status should also be observable.
    mutable Signal m_signal;
};
 
std::ostream& operator<<(std::ostream& os, ObservableStatus const& s);
 
 
}  // namespace daq
#endif  // #ifndef OCM_DAQ_DAQ_STATUS_HPP_