telRepubBusinessLogic.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_REUSABLECOMPONENT_TELREPUB_TELREPUBBUSINESSLOGIC_HPP_
#define RTCTK_REUSABLECOMPONENT_TELREPUB_TELREPUBBUSINESSLOGIC_HPP_
 
#include "ddsPubThread.hpp"
#include "rtctk/componentFramework/ddsPub.hpp"
#include "udpReceiver.hpp"
 
#include "rtctk/componentFramework/rtcComponent.hpp"
#include "rtctk/componentFramework/runnable.hpp"
#include "rtctk/componentFramework/serviceContainer.hpp"
 
#include <rad/logger.hpp>
#include <rad/mal/utils.hpp>
 
#include <cstdint>
#include <chrono>
#include <iostream>
 
namespace rtctk::telRepub {
 
using namespace rtctk::componentFramework;  
 
using LifeCycle = Runnable<RtcComponent>;
 
class TelRepubBusinessLogic : public LifeCycle::BizLogicIf {
public:
    using ComponentType = LifeCycle;
    TelRepubBusinessLogic(const std::string& name,
                          ServiceContainer& services);
 
    virtual ~TelRepubBusinessLogic();
 
    void ActivityStarting(StopToken st) override;
 
    void ActivityRecovering(StopToken st) override;
 
    void ActivityInitialising(StopToken st) override;
 
    void ActivityEnabling(StopToken st) override;
 
    void ActivityDisabling(StopToken st) override;
 
    void ActivityGoingRunning(StopToken st) override;
 
    void ActivityGoingIdle(StopToken st) override;
 
    void ActivityRunning(StopToken st) override;
 
    void ActivityUpdating(StopToken st, Payload args) override;
 
    bool GuardUpdatingAllowed(Payload args) override;
 
protected:
    struct DdsPublisherContext {
        DdsPublisherContext(std::uint16_t sim_freq_arg,
                            std::int32_t mudpi_topic_id_arg,
                            std::int32_t receiver_index_arg,
                            componentFramework::DataWriter* dw,
                            componentFramework::ComponentMetricsIf& metrics,
                            std::uint32_t queue_size)
            : sim_freq(sim_freq_arg)
            , mudpi_topic_id(mudpi_topic_id_arg)
            , receiver_index(receiver_index_arg)
            , publisher(std::make_unique<PubThread<rtctk::componentFramework::AgnosticTopic>>(dw, metrics, queue_size)) {
        }
        DdsPublisherContext(DdsPublisherContext&&) noexcept = default;
        std::uint16_t sim_freq;
        std::uint16_t mudpi_topic_id;
        std::uint16_t receiver_index;
        std::unique_ptr<PubThread<rtctk::componentFramework::AgnosticTopic>> publisher;
    };
    std::map<mudpi::uint16_t, PubThreadBase<>&>
    BuildUdpReceiverAssociation(std::uint16_t receiver_idx);
 
    void CreateMudpiReceivers();
 
    void DeleteMudpiReceivers();
 
    void CreateDdsPubs();
    void DeleteDdsPubs();
 
    const std::string m_name;
    uint16_t m_sim_freq;
 
    std::unique_ptr<DdsPub> m_dds_pub;
 
    rtctk::componentFramework::ServiceContainer& m_service_container;
 
    componentFramework::ComponentMetricsIf& m_component_metrics;
 
    std::vector<std::unique_ptr<UdpReceiver>> m_udp_receivers;
 
    std::vector<DdsPublisherContext> m_pub_threads;
};
 
}  // namespace rtctk::telRepub
 
#endif  // RTCTK_REUSABLECOMPONENT_TELREPUB_TELREPUBBUSINESSLOGIC_HPP_