CUnitPatterns.hpp

Go to the documentation of this file.

#ifndef LIBS_CHANNELS_CUNITPATTERNS_HPP_
#define LIBS_CHANNELS_CUNITPATTERNS_HPP_
 
#include "channels/WiredAttributes.hpp"
#include "model/constants.hpp"
#include "units/model/enums.hpp"
 
class CUnitPattern
{
public:
    struct SChannelType
    {
        SChannelType(iv::channels::eChannelBaseType chBaseType, iv::channels::eChannelSpecificType chSpecificType);
        SChannelType() = delete;
        virtual ~SChannelType() = default;
 
        iv::channels::eChannelBaseType m_channelBaseType;
        iv::channels::eChannelSpecificType m_channelSpecificType;
    };
 
    struct SChannelTypeWired final : public SChannelType
    {
        SChannelTypeWired(iv::channels::eChannelBaseType chBaseType, iv::channels::eChannelSpecificType chSpecificType,
                          iv::channels::WiredAttributes::eIOType ioType);
        SChannelTypeWired() = delete;
        ~SChannelTypeWired() override = default;
 
        iv::channels::WiredAttributes::eIOType m_ioType;
    };
 
    typedef std::pair<iv::types::channelOrder, iv::types::channelOrder>
            TChannelRange;// [start channel Id, end channel Id]
    typedef std::map<TChannelRange, SChannelType *> TMapChannelRangeType;
 
    CUnitPattern(iv::units::eUnitType unitType, int32_t maxWiredChannels);
    CUnitPattern() = delete;
    ~CUnitPattern();
    CUnitPattern(const CUnitPattern &other);
    CUnitPattern(CUnitPattern &&other) = delete;
    CUnitPattern &operator=(const CUnitPattern &other) = default;
    CUnitPattern &operator=(CUnitPattern &&other) = delete;
 
    static std::vector<iv::types::Range<iv::types::channelOrder>>
    getRangeChannelOrder(iv::channels::eChannelSpecificType channelSpecificType, iv::units::eUnitType unitType);
    static void getRangeUnitId(iv::units::eUnitType unitType, iv::types::unitId &start, iv::types::unitId &end);
    static bool isUnitIdValid(iv::units::eUnitType unitType, const iv::types::unitId &unitId);
    static iv::channels::eChannelBaseType getBaseType(iv::channels::eChannelSpecificType chSpecificType);
 
    [[nodiscard]] const TMapChannelRangeType &getWiredChannelRangeType() const;
    [[nodiscard]] const SChannelTypeWired *getWiredChannelType(uint16_t channelId) const;
    [[nodiscard]] const std::vector<SChannelType *> &getNonWiredChannelTypesAllowed() const;
 
    [[nodiscard]] bool canHaveChannels() const;
    [[nodiscard]] bool hasUnitInfo() const;
    [[nodiscard]] bool isWiredChannelWATankChangeable(uint16_t channelId) const;
 
private:
    void prvAddNonWiredChannelTypeAllowed(iv::channels::eChannelSpecificType chSpecificType);
    void prvAddWiredChannelTypeRange(iv::channels::eChannelSpecificType chSpecificType, TChannelRange range,
                                     iv::channels::WiredAttributes::eIOType ioType);
    void prvBuildPatternAIM18();
    void prvBuildPatternDIM36();
    void prvBuildPatternDIOM24();
    static void prvBuildPatternRMS();
    void prvBuildPatternLUM();
    void prvBuildPatternPMM();
    void prvBuildPatternTIM28();
    static void prvBuildPatternSlim();
    void prvAddCommonNonWiredChannelTypesAllowed(iv::units::eUnitType unitType);
    void prvBuildPattern(iv::units::eUnitType unitType);
 
    iv::units::eUnitType m_unitType;
    int32_t m_maxWiredChannels;
    TMapChannelRangeType m_wiredChannelsType;// structure for wired channels
 
    std::vector<SChannelType *>
            m_nonWiredChannelTypesAllowed;// for this particular type of unit, what type of non wired channels can be added
};
 
class CUnitPatterns
{
public:
    static constexpr uint16_t kUnitsEmptyId = 0;
    static constexpr uint32_t kUnitsStartId = 1;
    static constexpr uint16_t kChannelsEmptyId = 0;
    static constexpr uint16_t kChannelsStartId = 1;
    static constexpr uint16_t kMaxChannelsAIM18 = 18;
    static constexpr uint16_t kMaxChannelsDIM36 = 36;
    static constexpr uint16_t kMaxChannelsDIOM24 = 24;
    static constexpr uint16_t kMaxChannelsPMM = 27;
    static constexpr uint16_t kMaxChannelsTIM28 = 32;
    static constexpr uint16_t kMaxChannelsSLIM = 4;
 
    static const CUnitPatterns &getInstance();
 
    static std::pair<uint16_t, uint16_t> getEmptyUnitChannel();
    static std::pair<uint16_t, uint16_t> getDefaultUnitChannel();
 
    [[nodiscard]] const CUnitPattern &getPattern(iv::units::eUnitType unitType) const;
    [[nodiscard]] const CUnitPattern::SChannelTypeWired *getWiredChannelType(iv::units::eUnitType unitType, uint16_t channelId) const;
    [[nodiscard]] std::vector<iv::channels::eChannelSpecificType>
    getNonWiredChannelTypesAllowed(iv::units::eUnitType unitType) const;
 
    [[nodiscard]] bool isWiredChannelWATankChangeable(iv::units::eUnitType unitType, uint16_t channelId) const;
 
    CUnitPatterns(const CUnitPatterns &other) = delete;
    CUnitPatterns(CUnitPatterns &&other) = delete;
    CUnitPatterns &operator=(const CUnitPatterns &other) = delete;
    CUnitPatterns &operator=(CUnitPatterns &&other) = delete;
 
private:
    CUnitPatterns();
    ~CUnitPatterns() = default;
 
    static int32_t prvMaxWiredChannels(iv::units::eUnitType unitType);
 
    std::map<iv::units::eUnitType, CUnitPattern> m_unitPatterns;
};
 
#endif /* LIBS_CHANNELS_CUNITPATTERNS_HPP_ */