source.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_common_libdaq
 * @copyright 2022 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 <Metadaqif.hpp>
#include <Recif.hpp>
#include <boost/signals2/signal.hpp>
#include <fmt/ostream.h>
 
#include "state.hpp"
 
namespace daq {
 
/**
 * Simple class that holds the source and associated state.
 *
 * @ingroup daq_common_libdaq
 */
template <class T>
struct Source {
    using StateSignal = boost::signals2::signal<void(State, bool)>;
 
    Source(T&) = delete;
    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_common_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 const& 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_common_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 const& 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>;
 
/**
 * Data acquisition sources.
 */
class DaqSources {
public:
    DaqSources() = default;
    explicit DaqSources(std::vector<PrimSource> prim_sources, std::vector<MetaSource> meta_sources)
        : m_prim_sources(std::move(prim_sources)), m_meta_sources(std::move(meta_sources)) {
    }
    std::vector<PrimSource> const& GetPrimarySources() const noexcept {
        return m_prim_sources;
    }
 
    std::vector<PrimSource>& GetPrimarySources() noexcept {
        return m_prim_sources;
    }
 
    std::vector<MetaSource> const& GetMetadataSources() const noexcept {
        return m_meta_sources;
    }
 
    std::vector<MetaSource>& GetMetadataSources() noexcept {
        return m_meta_sources;
    }
 
private:
    std::vector<PrimSource> m_prim_sources;
    std::vector<MetaSource> m_meta_sources;
};
 
}  // namespace daq
 
template <class T>
struct fmt::formatter<daq::Source<T>> : ostream_formatter {};
 
template <>
struct fmt::formatter<daq::PrimSource> : ostream_formatter {};
 
template <>
struct fmt::formatter<daq::MetaSource> : ostream_formatter {};
 
#endif  // #ifndef OCF_DAQ_SOURCE_HPP_