source.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libdaq
 * @copyright 2021 ESO - European Southern Observatory
 *
 * @brief Declarations for `daq::Source` and related classes.
 */
#ifndef OCF_DAQ_SOURCE_HPP_
#define OCF_DAQ_SOURCE_HPP_
#include "config.hpp"
 
#include <memory>
#include <string>
 
#include <boost/signals2/signal.hpp>
#include <Metadaqif.hpp>
#include <Recif.hpp>
 
#include "state.hpp"
 
namespace daq {
 
/**
 * Simple class that holds the source and associated state.
 *
 * @ingroup daq_ocm_libdaq
 */
template<class T>
struct Source {
    using StateSignal = boost::signals2::signal<void(State, bool)>;
 
    Source(T&& s) : m_source(std::move(s)){}
    friend std::ostream& operator<<(std::ostream& os, Source<T> const& s) {
        os << s.GetSource() << ", state=" << s.GetState() << ", error_flag="
           << (s.GetErrorFlag() ? "true" : "false");
        return os;
    }
 
 
    /**
     * Connect `subscriber` that is invoked on state changes.
     *
     * Type requirements of `subscriber`:
     * Signature void(State, bool)
     */
    template<class Subscriber>
    boost::signals2::connection ConnectStateListener(Subscriber subscriber) {
        return m_state_signal.connect(std::move(subscriber));
    }
 
    void SetState(State state, std::optional<bool> error_flag = {}) {
        if (error_flag) {
            m_error_flag = *error_flag;
        }
        m_state = state;
        m_state_signal(m_state, m_error_flag);
    }
 
    void ClearErrorFlag() {
        m_error_flag = false;
        m_state_signal(m_state, m_error_flag);
    }
 
    void SetErrorFlag() {
        m_error_flag = true;
        m_state_signal(m_state, m_error_flag);
    }
 
    bool GetErrorFlag() const {
        return m_error_flag;
    }
    State GetState() const {
        return m_state;
    }
 
    T& GetSource() {
        return m_source;
    }
 
    T const& GetSource() const {
        return m_source;
    }
 
  protected:
    T m_source;
    State m_state = State::NotStarted;
    bool m_error_flag = false;
    StateSignal m_state_signal;
};
 
/**
 * Keeps relevant state to be able to communicate with a primary data source.
 *
 * @ingroup daq_ocm_libdaq
 */
class PrimSource {
  public:
    using RrClient = recif::RecCmdsAsync;
 
    /**
     * @throws std::invalid_argument if name or client is invalid.
     */
    PrimSource(std::string name, std::shared_ptr<RrClient> client) : m_name(std::move(name)), m_rr_client(std::move(client)) {
        if (m_name.empty()) {
            throw std::invalid_argument("'name' is invalid");
        }
        if (!m_rr_client) {
            throw std::invalid_argument("'client' is invalid");
        }
    }
    PrimSource(PrimSource&&) = default;
    PrimSource(PrimSource const&) = default;
    PrimSource& operator=(PrimSource&) = default;
    PrimSource& operator=(PrimSource&&) = default;
 
    std::string_view GetName() const {
        return m_name;
    }
 
    RrClient& GetRrClient() {
        return *m_rr_client;
    }
 
    friend std::ostream& operator<<(std::ostream& os, PrimSource const& s) {
        os << "PrimSource: " << s.m_name;
        return os;
    }
 
  private:
    std::string m_name;
    std::shared_ptr<RrClient> m_rr_client;
};
 
/**
 * Keeps relevant state to be able to communicate with a primary data source.
 *
 * @ingroup daq_ocm_libdaq
 */
class MetaSource {
  public:
    using RrClient = metadaqif::MetaDaqAsync;
 
    /**
     * @throws std::invalid_argument if name or client is invalid.
     */
    MetaSource(std::string name, std::shared_ptr<RrClient> client) : m_name(std::move(name)), m_rr_client(std::move(client)) {
        if (m_name.empty()) {
            throw std::invalid_argument("'name' is invalid");
        }
        if (!m_rr_client) {
            throw std::invalid_argument("'client' is invalid");
        }
    }
    MetaSource(MetaSource&&) = default;
    MetaSource(MetaSource const&) = default;
    MetaSource& operator=(MetaSource const&) = default;
    MetaSource& operator=(MetaSource&&) = default;
 
    std::string_view GetName() const {
        return m_name;
    }
 
    RrClient& GetRrClient() {
        return *m_rr_client;
    }
 
    friend std::ostream& operator<<(std::ostream& os, MetaSource const& s) {
        os << "MetaSource: " << s.m_name;
        return os;
    }
 
private:
    std::string m_name;
    std::shared_ptr<RrClient> m_rr_client;
};
 
using SourceVariant = std::variant<PrimSource, MetaSource>;
}
 
#endif // #ifndef OCF_DAQ_SOURCE_HPP_