Unit.hpp

Go to the documentation of this file.

#ifndef IV_SRC_UNITS_MODEL_UNIT_HPP_
#define IV_SRC_UNITS_MODEL_UNIT_HPP_
 
#include "channels/AbstractChannel.hpp"
#include "filehandlers/xmlFile.hpp"
#include "logs/AbstractProgress.hpp"
#include "units/model/UnitInfo.hpp"
#include "units/model/enums.hpp"
 
namespace iv::units
{
 
class Unit
{
    friend class Units;
 
public:
    Unit();
 
    Unit(iv::types::unitId id, iv::units::eUnitType unitType);
 
    void update(const iv::units::Unit &other);
    bool load(const iv::file::xml::File &xml);
    bool save(const std::shared_ptr<iv::file::xml::File> &xml) const;
 
    [[nodiscard]] std::shared_ptr<Unit> clone() const;
 
    [[nodiscard]] iv::types::unitId getId() const;
    [[nodiscard]] std::optional<iv::units::eUnitType> getType() const;
    [[nodiscard]] iv::units::UnitInfo &getUnitInfo();
    [[nodiscard]] iv::types::timestamp getLastHeartbeat() const;
 
    [[nodiscard]] bool hasChannels() const;
    void createSystemChannels();
 
    void initializeChannels(const std::shared_ptr<AbstractProgress> &progress);
    // Unit's channel manipulation: Controller
    [[nodiscard]] std::shared_ptr<iv::channels::AbstractChannel> extractChannel(iv::types::channelOrder channelOrder);
    [[nodiscard]] std::shared_ptr<iv::channels::AbstractChannel> extractChannel(const iv::types::channelId &channelId);
 
    bool changeChannelId(const iv::types::channelId &channelId, const iv::types::channelId &newChannelId);
    bool changeChannelOrder(iv::types::channelOrder channelOrder, iv::types::channelOrder newChannelOrder);
 
    bool deleteChannel(iv::types::channelOrder channelOrder);
    bool deleteChannel(const iv::types::channelId &channelId);
 
    std::weak_ptr<iv::channels::AbstractChannel>
    createChannel(iv::channels::eChannelSpecificType channelType,
                  std::optional<iv::types::channelOrder> channelOrder = std::nullopt,
                  const std::optional<iv::types::channelId> &channelId = std::nullopt);
 
    bool insertChannel(std::shared_ptr<iv::channels::AbstractChannel> channel);
 
    [[nodiscard]] std::weak_ptr<iv::channels::AbstractChannel> getChannel(iv::types::channelOrder channelOrder) const;
    [[nodiscard]] std::weak_ptr<iv::channels::AbstractChannel> getChannel(const iv::types::channelId &channelId) const;
    [[nodiscard]] std::weak_ptr<iv::channels::AbstractChannel> getChannelByShipyardTag(const std::string &channelTag);
 
    [[nodiscard]] const std::unordered_map<iv::types::channelId, std::shared_ptr<iv::channels::AbstractChannel>> &
    getChannels() const;
    const std::map<iv::types::channelOrder, std::shared_ptr<iv::channels::AbstractChannel>> &
    getActiveChannels(bool refreshCache = false) const;
    [[nodiscard]] const std::map<iv::types::channelOrder, std::shared_ptr<iv::channels::AbstractChannel>> &
    getChannelsByOrder() const;
    [[nodiscard]] std::shared_ptr<std::vector<std::weak_ptr<iv::channels::AbstractChannel>>>
    getActiveChannelsByGroupId(const iv::types::groupId &groupId, bool refreshCache = false) const;
    [[nodiscard]] std::map<iv::types::indexChannel, std::shared_ptr<iv::channels::AbstractChannel>> &
    getChannelsByIndex();
 
    [[nodiscard]] std::optional<iv::types::channelOrder> getFirstFreeChannelOrder(
            std::optional<iv::channels::eChannelSpecificType> channelType = std::nullopt,
            const std::optional<std::function<bool(iv::types::channelOrder)>> &addedCondition = std::nullopt) const;
 
    std::pair<iv::alarms::eAlarmState, iv::alarms::eAlarmPriority> calculateUnitAlarmStatePriority() const;
 
    void setOfflineChannel(const std::weak_ptr<iv::channels::AbstractChannel> &offlineChannel);
    void setCanAFailChannel(const std::weak_ptr<iv::channels::AbstractChannel> &canAFailChannel);
    void setCanBFailChannel(const std::weak_ptr<iv::channels::AbstractChannel> &canBFailChannel);
    void setCanCFailChannel(const std::weak_ptr<iv::channels::AbstractChannel> &canCFailChannel);
    void setHeartbeatChannel(const std::weak_ptr<iv::channels::AbstractChannel> &heartbeatChannel);
 
    std::weak_ptr<iv::channels::AbstractChannel> getOfflineChannel();
    std::weak_ptr<iv::channels::AbstractChannel> getCanAFailChannel();
    std::weak_ptr<iv::channels::AbstractChannel> getCanBFailChannel();
    std::weak_ptr<iv::channels::AbstractChannel> getCanCFailChannel();
    std::weak_ptr<iv::channels::AbstractChannel> getHeartbeatChannel();
 
    void setLasHeartbeat(iv::comms::eLomLine line, iv::types::timestamp timestamp);
    iv::types::timestamp getLastHeartbeat(iv::comms::eLomLine line) const;
    // Checks
    [[nodiscard]] bool isStation() const;
    [[nodiscard]] bool isLIM() const;
    [[nodiscard]] bool isLOM() const;
    [[nodiscard]] std::string getName(bool isNotInProjectUnit = false) const;
 
    [[nodiscard]] bool isOn() const;
    [[nodiscard]] bool existsChannel(const iv::types::channelId &channelId) const;
    bool isOnOnCanLine(comms::eLomLine line) const;
 
public:
    void prvCreateLomSystemChannels();
    void prvCreateKLimSystemChannels();
 
    bool m_isEnabled {true};
    //Only for editDiamar
    std::optional<iv::comms::eHeartbeatState> m_lastHeartbeatState;
    iv::types::unitId m_id {0};
    std::string m_internalDescription;
    iv::types::cabinetId m_cabinetId;
    std::optional<iv::units::eUnitType> m_unitType;
 
    iv::units::UnitInfo m_unitInfo {};
 
    std::mutex m_lomCommunicationMutex;
 
private:
    bool changeChannelsDefaultId(const iv::types::unitId &newUnitId);
    void updateChannelsUnitId();
 
    std::unordered_map<iv::types::channelId, std::shared_ptr<iv::channels::AbstractChannel>> m_channels;
 
    std::map<iv::types::channelOrder, std::shared_ptr<iv::channels::AbstractChannel>> m_channelsByOrder;
    std::map<iv::types::indexChannel, std::shared_ptr<iv::channels::AbstractChannel>> m_channelsByIndex;
 
    mutable std::optional<std::map<iv::types::channelOrder, std::shared_ptr<iv::channels::AbstractChannel>>>
            m_activeChannelsByOrder;
    mutable std::map<iv::types::groupId, std::shared_ptr<std::vector<std::weak_ptr<iv::channels::AbstractChannel>>>>
            m_channelsByGroupId;
 
    std::weak_ptr<iv::channels::AbstractChannel> m_offlineChannel;
    std::weak_ptr<iv::channels::AbstractChannel> m_canAFailChannel;
    std::weak_ptr<iv::channels::AbstractChannel> m_canBFailChannel;
    std::weak_ptr<iv::channels::AbstractChannel> m_canCFailChannel;
    std::weak_ptr<iv::channels::AbstractChannel> m_heartbeatChannel;
 
    std::map<iv::comms::eLomLine, iv::types::timestamp> m_lastHeartbeat;
 
private:
    struct Sections
    {
        static constexpr std::string_view unit {"Unit"};
        static constexpr std::string_view systemChannels {"SystemChannels"};
        static constexpr std::string_view channels {"Channels"};
        static constexpr std::string_view channel {"Channel"};
        static constexpr std::string_view unitData {"Data"};
    };
    struct Keys
    {
        static constexpr std::string_view unitId {"Id"};
        static constexpr std::string_view unitType {"Type"};
        static constexpr std::string_view isEnabled {"Enabled"};
        static constexpr std::string_view internalDescription {"InternalDescription"};
        static constexpr std::string_view cabinetId {"CabinetId"};
        static constexpr std::string_view offlineChannel {"OfflineChannel"};
        static constexpr std::string_view canAFailChannel {"CanAFailChannel"};
        static constexpr std::string_view canBFailChannel {"CanBFailChannel"};
        static constexpr std::string_view canCFailChannel {"CanCFailChannel"};
        static constexpr std::string_view heartbeatChannel {"HeartbeatChannel"};
    };
    struct DefaultValues
    {
        static constexpr std::string string {};
        static constexpr std::string_view unitType {"Aim18"};
        static constexpr iv::types::unitId unitId {0};
        static constexpr bool isEnabled {true};
    };
};
 
}// namespace iv::units
 
#endif//IV_SRC_UNITS_MODEL_UNIT_HPP_