businessLogic.hpp

Go to the documentation of this file.

#ifndef RTCTK_TELSUB_BUSINESSLOGIC_HPP
#define RTCTK_TELSUB_BUSINESSLOGIC_HPP
#include <functional>
#include <iosfwd>
#include <memory>
 
#include "rtctk/componentFramework/alertServiceIf.hpp"
#include "rtctk/componentFramework/dataPointPath.hpp"
#include <rtctk/componentFramework/logger.hpp>
#include <rtctk/componentFramework/repositoryIfUtils.hpp>
#include <rtctk/componentFramework/runnable.hpp>
#include <rtctk/componentFramework/runtimeRepoIf.hpp>
#include <rtctk/componentFramework/serviceContainer.hpp>
 
#include <rtctk/telSub/operationalLogic.hpp>
#include <vector>
 
namespace rtctk::telSub {

std::ostream& operator<<(std::ostream& stream, const std::vector<std::string>& data);

struct OperationalLogicFactoryParams {
    ShmParams shm_params;
    DdsParams dds_params;
    CorrelatorParams correlator_params;
    OperationalParams operational_params;
};
 
using LifeCycle = rtctk::componentFramework::Runnable<rtctk::componentFramework::RtcComponent>;

class BusinessLogic : public LifeCycle::BizLogicIf {
public:
    using ComponentType = LifeCycle;
 
    using OperationalLogicFactory =
        std::function<std::unique_ptr<OperationalLogicIf>(const OperationalLogicFactoryParams&)>;
    BusinessLogic(const std::string& name,
                  componentFramework::ServiceContainer& services,
                  OperationalLogicFactory factory);
 
    void ActivityStarting(componentFramework::StopToken st) override;
    void ActivityInitialising(componentFramework::StopToken st) override;
    void ActivityEnabling(componentFramework::StopToken st) override;
    void ActivityDisabling(componentFramework::StopToken st) override;
    void ActivityGoingRunning(componentFramework::StopToken st) override;
    void ActivityGoingIdle(componentFramework::StopToken st) override;
    void ActivityRunning(componentFramework::StopToken st) override;
    void ActivityUpdating(componentFramework::StopToken st,
                          const componentFramework::JsonPayload& args) override;
    bool GuardUpdatingAllowed(const componentFramework::JsonPayload& args) override;
    void ActionClearAlerts() override;
 
protected:
    log4cplus::Logger& m_logger;
    std::string m_name;

    template <typename T>
    void GetParam(const rtctk::componentFramework::DataPointPath& path, T& value) {
        using namespace rtctk::componentFramework;
        auto fullpath = ""_dppath / DataPointPath(m_name) / path;
        value = m_rtr.GetDataPoint<T>(fullpath);
        LOG4CPLUS_INFO(m_logger, " - " << fullpath << ": " << value);
    }

    template <typename T>
    bool GetOptionalParam(const rtctk::componentFramework::DataPointPath& path, T& value) {
        using namespace rtctk::componentFramework;
        DataPointPath fullpath = ""_dppath / DataPointPath(m_name) / path;
        auto loaded = ::rtctk::componentFramework::GetOptionalParam(m_rtr, fullpath, value);
        if (loaded) {
            LOG4CPLUS_INFO(m_logger, " - " << fullpath << ": " << value);
        }
        return loaded;
    }
 
    std::vector<DataPointPath> GetTopicPaths() {
        using namespace rtctk::componentFramework;
        DataPointPath fullpath = ""_dppath / DataPointPath(m_name) / "static/dds_topics"_dppath;
        auto [datapoints, children] = m_rtr.GetChildren(fullpath);
        return children;
    }

    std::optional<numapp::NumaPolicies>
    LoadNumaPolicies(const rtctk::componentFramework::DataPointPath& path);
 
    rtctk::componentFramework::RuntimeRepoIf& m_rtr;
 
    rtctk::componentFramework::ComponentMetricsIf& m_metrics;
 
    rtctk::componentFramework::AlertServiceIf& m_alerts;
 
    OperationalLogicFactory m_operational_logic_factory;
    std::unique_ptr<OperationalLogicIf> m_operational_logic;
};
 
}  // namespace rtctk::telSub
 
#endif  // RTCTK_TELSUB_BUSINESSLOGIC_HPP