businessLogic.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_REUSABLECOMPONENT_MUDPIPUB_BUSINESSLOGIC_HPP
#define RTCTK_REUSABLECOMPONENT_MUDPIPUB_BUSINESSLOGIC_HPP
 
#include <optional>
#include <string>
 
#include <rtctk/componentFramework/componentMetricsIf.hpp>
#include <rtctk/componentFramework/durationMonitor.hpp>
#include <rtctk/componentFramework/frequencyEstimator.hpp>
#include <rtctk/componentFramework/rtcComponent.hpp>
#include <rtctk/componentFramework/runnable.hpp>
#include <rtctk/componentFramework/runtimeRepoIf.hpp>
#include <taiclock/taiClock.hpp>
 
#include <rtctk/mudpiPub/publisher.hpp>
 
namespace rtctk::mudpiPub {
 
using rtctk::componentFramework::RtcComponent;
using rtctk::componentFramework::Runnable;
 
using LifeCycle = Runnable<RtcComponent>;
 
class BusinessLogic : public LifeCycle::BizLogicIf {
public:
    using ComponentType = LifeCycle;
 
    using JsonPayload = rtctk::componentFramework::JsonPayload;
    using ServiceContainer = rtctk::componentFramework::ServiceContainer;
    using StopToken = rtctk::componentFramework::StopToken;
 
    // for each topic we have a vector of samples, where a sample is a vector of bytes
    using UserData = std::map<std::string, std::vector<std::vector<uint8_t>>>;
    using UserFunc = std::function<UserData(const std::string&)>;
 
    BusinessLogic(const std::string& name,
                  ServiceContainer& services,
                  UserFunc user_func = nullptr);
    virtual ~BusinessLogic() = default;
    void ActivityStarting(StopToken st) override;
    void ActivityInitialising(StopToken st) override;
    void ActivityRunning(StopToken st) override;
    void ActivityUpdating(StopToken st, const JsonPayload& args) override;
 
private:
    using DataPointPath = rtctk::componentFramework::DataPointPath;
    using RuntimeRepoIf = rtctk::componentFramework::RuntimeRepoIf;
    using ComponentMetricsIf = rtctk::componentFramework::ComponentMetricsIf;
 
    log4cplus::Logger& m_logger;
 
    AppCfg MakeAppCfg();
 
    void UpdateAppDynamicCfg(AppCfg& cfg);
 
    void UpdateCachedPublicationStartTime();
    taiclock::TaiClock::time_point ResolvePublicationStartTime() const;
 
    void WaitUntilPublicationDeadline(taiclock::TaiClock::time_point deadline,
                                      const StopToken& st) const;
 
    std::tuple<std::string, PubCfg> MakePubCfg(const std::string& prefix, const AppCfg& app_cfg);
 
    void
    UpdatePubDynamicCfg(const std::string& prefix, PubDynamicCfg& pub_cfg, const AppCfg& app_cfg);
 
    std::string m_name;
    RuntimeRepoIf& m_rtr;
    ComponentMetricsIf& m_metrics;
 
    perfc::CounterI64 m_pc_samples_published;
    perfc::ScopedRegistration m_pc_samples_published_reg;
    std::unique_ptr<rtctk::componentFramework::FrequencyEstimator<>> m_freq_estimator;
    std::unique_ptr<rtctk::componentFramework::DurationMonitor<>> m_dur_monitor;
 
    AppCfg m_cfg;  // configuration
    UserFunc m_user_func;
    std::vector<std::unique_ptr<Publisher>> m_publishers;
 
    std::atomic<bool> m_running = false;
 
    std::optional<taiclock::TaiClock::time_point> m_publication_start_time;
    std::string m_publication_start_timestamp;
};
 
}  // namespace rtctk::mudpiPub
 
#endif  // RTCTK_REUSABLECOMPONENT_MUDPIPUB_BUSINESSLOGIC_HPP