NetworkInfo.hpp

Go to the documentation of this file.

#ifndef IV_SRC_CHANNELS_NETWORKINFO_HPP_
#define IV_SRC_CHANNELS_NETWORKINFO_HPP_
 
#include "channels/structs.hpp"
#include "comms/enums.hpp"
 
#include <memory>
 
namespace iv::channels
{
 
class INetworkInfo;
 
static std::shared_ptr<iv::channels::INetworkInfo> createNetworkType(iv::comms::eProtocolType protocolType,
                                                                     const iv::types::networkId &networkId);
 
class INetworkInfo
{
public:
    enum class eDirection
    {
        In,
        Out
    };
 
    virtual ~INetworkInfo() = default;
 
    static std::shared_ptr<INetworkInfo> loadStatic(const iv::file::xml::node &nodeNetwork)
    {
        std::shared_ptr<INetworkInfo> networkInfo {nullptr};
        auto protocolType = magic_enum::enum_cast<iv::comms::eProtocolType>(
                nodeNetwork.getAttribute(Keys::protocol, DefaultValues::string));
 
        if (protocolType.has_value())
        {
            networkInfo = iv::channels::createNetworkType(protocolType.value(), DefaultValues::nameNetwork);
            networkInfo->load(nodeNetwork);
        }
 
        return networkInfo;
    }
 
    virtual void update(const std::shared_ptr<INetworkInfo> &other)
    {
        m_protocolType = other->m_protocolType;
        m_nameNetwork = other->m_nameNetwork;
        m_direction = other->m_direction;
    }
 
    virtual bool save(iv::file::xml::node &nodeNetwork) const
    {
        nodeNetwork.addAttribute(Keys::protocol, magic_enum::enum_name(m_protocolType));
        nodeNetwork.addAttribute(Keys::nameNetwork, m_nameNetwork);
        nodeNetwork.addAttribute(Keys::direction, magic_enum::enum_name(m_direction));
        return true;
    }
 
    [[nodiscard]] iv::types::networkId &nameNetwork()
    {
        return m_nameNetwork;
    }
 
    [[nodiscard]] iv::comms::eProtocolType protocolType() const
    {
        return m_protocolType;
    }
 
    [[nodiscard]] eDirection direction() const
    {
        return m_direction;
    }
 
    iv::channels::INetworkInfo::eDirection m_direction;
 
protected:
    virtual bool load(const iv::file::xml::node &nodeNetwork)
    {
        m_protocolType = magic_enum::enum_cast<iv::comms::eProtocolType>(
                                 nodeNetwork.getAttribute(Keys::protocol, DefaultValues::string))
                                 .value_or(DefaultValues::protocolType);
        m_nameNetwork = nodeNetwork.getAttribute(Keys::nameNetwork, DefaultValues::string);
        m_direction = magic_enum::enum_cast<iv::channels::INetworkInfo::eDirection>(
                              nodeNetwork.getAttribute(Keys::direction, DefaultValues::string))
                              .value_or(DefaultValues::direction);
 
        return true;
    }
 
    iv::comms::eProtocolType m_protocolType;
    iv::types::networkId m_nameNetwork;
 
private:
    struct Keys
    {
        static constexpr std::string_view protocol {"Type"};
        static constexpr std::string_view nameNetwork {"Name"};
        static constexpr std::string_view direction {"Direction"};
    };
 
    struct DefaultValues
    {
        static constexpr std::string string {};
        static constexpr iv::comms::eProtocolType protocolType {iv::comms::eProtocolType::Can};
        static constexpr iv::types::networkId nameNetwork {};
        static constexpr iv::channels::INetworkInfo::eDirection direction {iv::channels::INetworkInfo::eDirection::In};
    };
};
 
class J1939NetworkInfo final : public INetworkInfo
{
public:
    explicit J1939NetworkInfo(const iv::types::networkId &networkId);
 
    void update(const std::shared_ptr<INetworkInfo> &other) override;
    bool load(const iv::file::xml::node &nodeNetwork) override;
    bool save(iv::file::xml::node &nodeNetwork) const override;
 
    inline iv::channels::J1939RegisterInfo &getInfo()
    {
        return m_info;
    }
 
private:
    iv::channels::J1939RegisterInfo m_info;
 
    struct Sections
    {
        static constexpr std::string_view registerInfo {"J1939RegisterInfo"};
    };
};
 
class ModbusNetworkInfo final : public INetworkInfo
{
public:
    explicit ModbusNetworkInfo(const iv::types::networkId &networkId);
 
    void update(const std::shared_ptr<INetworkInfo> &other) override;
    bool load(const iv::file::xml::node &nodeNetwork) override;
    bool save(iv::file::xml::node &nodeNetwork) const override;
 
    iv::channels::ModbusRegisterInfo &getInfo()
    {
        return m_info;
    }
 
    iv::channels::ModbusRegisterInfo m_info;
 
private:
    struct Sections
    {
        static constexpr std::string_view registerInfo {"ModbusChannelInfo"};
    };
};
 
class Nmea0183NetworkInfo final : public INetworkInfo
{
public:
    explicit Nmea0183NetworkInfo(const iv::types::networkId &networkId);
 
    void update(const std::shared_ptr<INetworkInfo> &other) override;
    bool load(const iv::file::xml::node &nodeNetwork) override;
    bool save(iv::file::xml::node &nodeNetwork) const override;
 
    iv::channels::Nmea0183RegisterInfo &getInfo()
    {
        return m_info;
    }
 
    iv::channels::Nmea0183RegisterInfo m_info;
 
private:
    struct Sections
    {
        static constexpr std::string_view registerInfo {"Nmea0183RegisterInfo"};
    };
};
 
class Nmea2kNetworkInfo final : public INetworkInfo
{
public:
    explicit Nmea2kNetworkInfo(const iv::types::networkId &networkId);
 
    void update(const std::shared_ptr<INetworkInfo> &other) override;
    bool load(const iv::file::xml::node &nodeNetwork) override;
    bool save(iv::file::xml::node &nodeNetwork) const override;
 
    iv::channels::Nmea2kRegisterInfo &getInfo()
    {
        return m_info;
    }
 
    iv::channels::Nmea2kRegisterInfo m_info;
 
private:
    struct Sections
    {
        static constexpr std::string_view registerInfo {"Nmea2kRegisterInfo"};
    };
};
 
class VdrNetworkInfo final : public INetworkInfo
{
public:
    explicit VdrNetworkInfo(const iv::types::networkId &networkId);
 
    void update(const std::shared_ptr<INetworkInfo> &other) override;
    bool load(const iv::file::xml::node &nodeNetwork) override;
    bool save(iv::file::xml::node &nodeNetwork) const override;
 
    iv::channels::VdrRegisterInfo &getInfo()
    {
        return m_info;
    }
 
    iv::channels::VdrRegisterInfo m_info;
 
private:
    struct Sections
    {
        static constexpr std::string_view registerInfo {"VdrRegisterInfo"};
    };
};
 
static std::shared_ptr<iv::channels::INetworkInfo> createNetworkType(iv::comms::eProtocolType protocolType,
                                                                     const iv::types::networkId &networkId)
{
    switch (protocolType)
    {
        case iv::comms::eProtocolType::J1939:
            return std::make_shared<iv::channels::J1939NetworkInfo>(networkId);
 
        case iv::comms::eProtocolType::Modbus:
            return std::make_shared<iv::channels::ModbusNetworkInfo>(networkId);
 
        case iv::comms::eProtocolType::Nmea0183:
            return std::make_shared<iv::channels::Nmea0183NetworkInfo>(networkId);
 
        case iv::comms::eProtocolType::Vdr:
            return std::make_shared<iv::channels::VdrNetworkInfo>(networkId);
            
        case iv::comms::eProtocolType::Nmea2k:
            return std::make_shared<iv::channels::Nmea2kNetworkInfo>(networkId);
        default:
            break;
    }
 
    return nullptr;
}
 
}// namespace iv::channels
 
#endif//IV_SRC_CHANNELS_NETWORKINFO_HPP_