ICommunicationController.hpp

Go to the documentation of this file.

#ifndef IV_SRC_COMMS_ICOMMUNICATIONCONTROLLER_HPP_
#define IV_SRC_COMMS_ICOMMUNICATIONCONTROLLER_HPP_
 
#include "comms/ICommunicationProtocol.hpp"
#include "diamar/AppFailuresLoggerManager.hpp"
#include "threads/Thread.hpp"
#include "threads/ThreadRunnablePeriodic.hpp"
#include "threads/WatchDog.hpp"
 
#include <map>
#include <memory>
#include <utility>
 
namespace iv::channels
{
class AbstractChannel;
}
 
namespace iv::comms
{
 
class ICommunicationController
{
public:
    ICommunicationController() = default;
    ICommunicationController(const std::shared_ptr<iv::model::comms::NetworkData> &networkData,
                             std::unique_ptr<iv::comms::ICommunicationDriver> driver, std::shared_ptr<bool> isEnabled);
    ICommunicationController(const ICommunicationController &other) = delete;
    ICommunicationController(ICommunicationController &&other) = delete;
 
    virtual ~ICommunicationController()
    {
        if (m_driver)
        {
            m_driver->stop();
            m_driver->end();
        }
    }
 
    ICommunicationController &operator=(const ICommunicationController &other) = delete;
    ICommunicationController &operator=(ICommunicationController &&other) = delete;
 
    virtual void addChannel(const std::shared_ptr<iv::channels::AbstractChannel> &channel) = 0;
    virtual void initialize() = 0;
    virtual bool frame() = 0;
 
    void pause() const
    {
        if (auto fallBack = m_fallbackComm.lock())
        {
            iv::threads::WatchDog::pauseThread(fallBack->getNetworkId());
        }
        if (not*m_isEnabled)
        {
            return;
        }
        iv::threads::WatchDog::pauseThread(m_networkId);
        *m_isEnabled = false;
        m_driver->stop();
    }
 
    void resume() const
    {
        if (*m_isEnabled)
        {
            return;
        }
        iv::threads::WatchDog::resumeThread(m_networkId);
        m_driver->start();
        *m_isEnabled = true;
    }
 
    [[nodiscard]] iv::types::networkId getNetworkId() const
    {
        return m_networkId;
    }
 
    [[nodiscard]] std::shared_ptr<iv::model::comms::NetworkData> getCommConfig() const
    {
        return m_commConfig;
    }
 
    [[nodiscard]] std::shared_ptr<iv::comms::ICommunicationDriver> getDriver() const
    {
        return m_driver;
    }
 
    [[nodiscard]] bool hasChannel(const iv::types::channelId &channelId) const
    {
        return m_channels.contains(channelId);
    }
 
    [[nodiscard]] bool isEnabled()
    {
        return *m_isEnabled;
    }
 
protected:
    iv::types::networkId m_networkId;
    std::shared_ptr<bool> m_isEnabled;
 
    std::shared_ptr<iv::model::comms::NetworkData> m_commConfig;
    std::shared_ptr<iv::comms::ICommunicationProtocol> m_protocol;
    std::shared_ptr<iv::comms::ICommunicationDriver> m_driver;
    std::map<iv::types::channelId, std::shared_ptr<iv::channels::AbstractChannel>> m_channels;
    std::weak_ptr<iv::channels::AbstractChannel> m_errorChannel;
    std::weak_ptr<iv::channels::AbstractChannel> m_heartbeatChannel;
    std::weak_ptr<iv::comms::ICommunicationController> m_fallbackComm;
 
    std::weak_ptr<iv::diamar::AppFailuresLoggerManager> m_appFailuresLoggerManager;
};
 
}// namespace iv::comms
 
#endif//IV_SRC_COMMS_ICOMMUNICATIONCONTROLLER_HPP_