Units.hpp

Go to the documentation of this file.

#ifndef IV_SRC_UNITS_MODEL_UNITS_HPP_
#define IV_SRC_UNITS_MODEL_UNITS_HPP_
 
#include "core/defines.hpp"
#include "units/model/Unit.hpp"
 
#include <map>
#include <unordered_set>
 
namespace iv::units
{
 
class Units : public std::map<iv::types::unitId, std::shared_ptr<iv::units::Unit>>
{
public:
    bool load(const iv::file::xml::node &nodeDataProject, std::string_view unitsFolderPath);
    bool save(iv::file::xml::node &nodeDataProject, std::string_view unitsFolderPath,
              const std::optional<std::shared_ptr<std::vector<std::shared_ptr<iv::file::xml::File>>>> &savingFilesOut =
                      std::nullopt) const;
 
    void update(Units &other);
 
    [[nodiscard]] bool hasChannels() const;
    [[nodiscard]] bool hasRmsUnit() const;
    [[nodiscard]] bool hasHeartbeatUnit() const;
    [[nodiscard]] bool hasCommFailUnit() const;
    [[nodiscard]] std::weak_ptr<Unit> rmsUnit();
    [[nodiscard]] std::weak_ptr<Unit> heartbeatUnit() const;
    [[nodiscard]] std::weak_ptr<Unit> commFailureUnit() const;
 
    [[nodiscard]] std::weak_ptr<Unit> getUnit(iv::types::unitId unitId) const;
    [[nodiscard]] std::weak_ptr<Unit> getUnitAt(uint32_t index);
    [[nodiscard]] std::optional<uint32_t> getUnitIndex(iv::types::unitId unitId) const;
    [[nodiscard]] std::vector<std::shared_ptr<iv::units::Unit>>
    getUnitsFromIds(const std::set<iv::types::unitId> &unitIds) const;
    [[nodiscard]] std::set<iv::types::unitId> unitsReadyForSetSpare() const;
 
    std::vector<std::weak_ptr<iv::channels::AbstractChannel>> getAllChannelsOrdered();
    std::map<iv::types::channelId, std::shared_ptr<iv::channels::AbstractChannel>> getAllChannels();
 
    void initializeChannels(const std::shared_ptr<AbstractProgress> &progress);
 
    // Controller
    std::weak_ptr<iv::channels::AbstractChannel> getChannel(const iv::types::channelId &channelId);
    std::weak_ptr<iv::channels::AbstractChannel> getChannelByShipyardTag(const std::string &channelTag);
    [[nodiscard]] bool existsChannel(const iv::types::channelId &channelId);
 
    bool addUnit(const std::shared_ptr<iv::units::Unit> &unit, bool createHeartbeatAndFailChannels = true);
 
    bool deleteUnit(iv::types::unitId unitId);
 
    bool changeUnitId(const iv::types::unitId &unitId, const iv::types::unitId &newUnitId);
    bool swapUnitsId(const iv::types::unitId &firstUnitId, const iv::types::unitId &secondUnitId);
 
    std::shared_ptr<std::vector<std::weak_ptr<iv::channels::AbstractChannel>>>
    getActiveChannelsByGroupId(const iv::types::groupId &groupId, bool refreshCache = false);
 
    void disableGroups(const std::unordered_set<iv::types::groupId> &groups);
 
    // Controller: Processed gets
    [[nodiscard]] std::shared_ptr<std::vector<std::weak_ptr<iv::channels::AbstractChannel>>>
    getAllChannelsInverted() const;
    [[nodiscard]] std::shared_ptr<std::vector<std::weak_ptr<iv::channels::AbstractChannel>>>
    getAllChannelsOffScan() const;
    [[nodiscard]] std::shared_ptr<std::vector<std::weak_ptr<iv::channels::AbstractChannel>>>
    getAllChannelsInhibited() const;
 
    [[nodiscard]] iv::types::unitId
    getFirstFreeUnitId(std::optional<iv::units::eUnitType> unitType = std::nullopt) const;
 
    [[nodiscard]] std::set<iv::types::unitId> getLOMsOnline(bool isNotInProjectUnit = false) const;
    [[nodiscard]] std::set<iv::types::unitId> getLOMsOffline(bool isNotInProjectUnit = false) const;
    [[nodiscard]] std::vector<iv::units::UnitIdAndName> getAllUnitsIdAndNameOnline() const;
    [[nodiscard]] std::set<iv::types::unitId> getIdsAllOnUnits() const;
    uint32_t getNumberOfChannels();
 
    void rearrangeCommHeartbeatAndFailureChannel() const;
    void rearrangeStationHeartbeatAndFailureChannel() const;
    void rearrangeWatchcallNodeHeartbeatAndFailureChannel() const;
    void createCommHeartbeatAndFailureChannel(const iv::types::networkId &commId) const;
    void createAllSystemChannels();
    void createStationHeartbeatAndFailureChannel(const iv::types::stationId &stationId) const;
    void createWatchcallNodeHearbeatAndFailureChannel(const iv::types::repeaterId &repeaterId) const;
 
    static std::shared_ptr<iv::channels::AbstractChannel>
    generateLomHeartBeatChannel(iv::types::unitId unitId, iv::types::channelOrder channelOrder);
    static std::shared_ptr<iv::channels::AbstractChannel> generateCanAFailChannel(iv::types::unitId unitId,
                                                                                  iv::types::channelOrder channelOrder);
    static std::shared_ptr<iv::channels::AbstractChannel> generateCanBFailChannel(iv::types::unitId unitId,
                                                                                  iv::types::channelOrder channelOrder);
    static std::shared_ptr<iv::channels::AbstractChannel> generateCanCFailChannel(iv::types::unitId unitId,
                                                                                  iv::types::channelOrder channelOrder);
    static std::shared_ptr<iv::channels::AbstractChannel>
    generateLomOfflineChannel(iv::types::unitId unitId, iv::types::channelOrder channelOrder);
 
    static std::shared_ptr<iv::channels::AbstractChannel>
    generateNetworkHeartbeatChannel(iv::types::networkId networkId, iv::types::channelOrder channelOrder);
 
    static std::shared_ptr<iv::channels::AbstractChannel>
    generateNetworkFailChannel(iv::types::networkId networkId, iv::types::channelOrder channelOrder);
 
    static std::shared_ptr<iv::channels::AbstractChannel>
    generateStationHeartbeatChannel(const iv::types::stationId &stationId, iv::types::channelOrder channelOrder);
 
    static std::shared_ptr<iv::channels::AbstractChannel>
    generateStationFailChannel(const iv::types::stationId &stationId, iv::types::channelOrder channelOrder);
 
    static std::shared_ptr<iv::channels::AbstractChannel>
    generateWatchcallNodeHeartbeatChannel(const iv::types::repeaterId &repeaterId,
                                          iv::types::channelOrder channelOrder);
 
    static std::shared_ptr<iv::channels::AbstractChannel>
    generateWatchcallNodeFailChannel(const iv::types::repeaterId &repeaterId, iv::types::channelOrder channelOrder);
 
private:
    bool loadUnit(iv::types::unitId unitId, std::string_view unitsFolderPath);
    void createUnitHeartbeatAndFailureChannels(iv::types::unitId newUnitId) const;
 
    [[nodiscard]] std::vector<std::shared_ptr<iv::channels::AbstractChannel>>
    extractUnitHeartbeatAndFailureChannels(iv::types::unitId unitId) const;
 
    struct Sections
    {
        static constexpr std::string_view units {"Units"};
        static constexpr std::string_view unit {"Unit"};
    };
 
    struct Keys
    {
        static constexpr std::string_view unitId {"Id"};
    };
 
    struct DefaultValues
    {
        static constexpr iv::types::unitId defaultUnitId {0};
    };
};
 
}// namespace iv::units
 
#endif//IV_SRC_UNITS_MODEL_UNITS_HPP_