recordingUnit.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_RECORDINGUNIT_HPP
#define RTCTK_COMPONENTFRAMEWORK_RECORDINGUNIT_HPP
 
#include "rtctk/componentFramework/repositoryIf.hpp"
#include <boost/signals2.hpp>
#include <filesystem>
#include <optional>
#include <shared_mutex>
#include <atomic>
 
namespace rtctk::componentFramework {
 
class RecordingUnit;
class ServiceContainer;
 
using RecUnitListType = std::list<std::unique_ptr<RecordingUnit>>;
using RecUnitFactoryType = std::function<RecUnitListType(std::string const&, ServiceContainer&)>;
 
template <class T, class... Args>
void AddRecUnit(RecUnitListType& units, Args&&... args) {
    units.emplace_back(std::make_unique<T>(std::forward<Args>(args)...));
}
 
class InvalidStateChange : public RtctkException {
    public:
        using RtctkException::RtctkException;
        explicit InvalidStateChange(const std::string& message) :
            RtctkException("Invalid Operation: " + message) {}
};
 
class InvalidSetting : public RtctkException {
    public:
        using RtctkException::RtctkException;
        explicit InvalidSetting(const std::string& message) :
            RtctkException("Invalid Setting: " + message) {}
};
 
// TODO: it makes sense to use ComponentMetrics to publish a datapoint with the recorded samples
// for each recording unit, this helps for debugging and performance analysis.
class RecordingUnit {
public:
    enum class State { STOPPED, PREPARING, IDLE, WAITING, RUNNING, FINISHED, FAILED };
 
    RecordingUnit(  std::string const& comp_id,
                    std::string const& unit_id,
                    RepositoryIf& rtr,
                    RepositoryIf& oldb);
 
    RecordingUnit() = delete;
 
    virtual ~RecordingUnit() = default;
 
    void ConnectWithLeaders(RecUnitListType& units);
 
    std::string GetId();
 
    State GetState();
 
    void CheckErrors();
    virtual void Prepare(const std::filesystem::path& file_path) = 0;
    virtual void Start() = 0;
    virtual std::optional<std::filesystem::path> Stop() = 0;
    virtual void Update();
 
    boost::signals2::connection
    Connect(const std::function<void(std::string const&, State const&)>& function);
 
protected:
    bool SetState(State state, State precondition);
 
    void SetState(State state, State precondition, const std::string& error_message);
 
    void SetFailed(const std::exception_ptr& exception);
    void SetStopped();
    bool HasLeaders();
    bool HasFirstLeaderStarted();
    bool HasLastLeaderFinished();
    void ResetLeaderStates();
 
    std::string m_comp_id;
    std::string m_unit_id;
    RepositoryIf& m_rtr;
    RepositoryIf& m_oldb;
    std::optional<std::filesystem::path> m_file_path;
    boost::signals2::signal<void(std::string const&, State const&)> m_signal;
 
private:
    std::mutex m_leader_mutex;
    std::atomic<State> m_state;
    std::exception_ptr m_exception = nullptr;
    std::shared_mutex m_exception_mutex;
    std::vector<std::string> m_leaders;
    std::map<std::string, State> m_leader_states;
    bool m_first_leader_started = false;
    bool m_last_leader_finished = false;
};
 
}  // namespace rtctk::componentFramework
 
#endif  // RTCTK_COMPONENTFRAMEWORK_RECORDINGUNIT_HPP