AbstractChannel.hpp

Go to the documentation of this file.

#ifndef IV_SRC_CHANNELS_ABSTRACTCHANNEL_HPP_
#define IV_SRC_CHANNELS_ABSTRACTCHANNEL_HPP_
 
#include "alarms/AlarmsManager.hpp"
#include "channels/NetworkInfo.hpp"
#include "channels/controller/AbstractChannel.hpp"
#include "channels/structs.hpp"
#include "comms/DataLoggerManager.hpp"
#include "model/enums.hpp"
 
#include <atomic>
 
static const std::string kPrvStrNoChannelValue = " - - - ";
 
namespace iv::units
{
class Unit;
}
 
namespace iv::channels
{
 
class AbstractChannel : public std::enable_shared_from_this<AbstractChannel>
{
    friend class iv::channels::controller::AbstractChannel;
 
public:
    virtual ~AbstractChannel() = default;
 
    virtual void update(AbstractChannel &other);
    virtual bool load(const iv::file::xml::node &nodeChannel);
    virtual bool save(iv::file::xml::node &nodeChannel) const;
 
    virtual std::shared_ptr<AbstractChannel> clone() = 0;
 
    void deinitialize();
    virtual void processAlarm(std::shared_ptr<iv::alarms::AlarmsManager> alarmManager) = 0;
    virtual void processValue() = 0;
 
    void setValue(std::optional<iv::types::channelValue> value, const std::optional<iv::alarms::Alarm> &alarm,
                  const std::optional<iv::types::networkId> &networkOrigin);
 
    virtual void calculateAlarm();
 
    template<typename T>
        requires std::is_same_v<T, bool> || std::is_same_v<T, int32_t> || std::is_same_v<T, uint32_t> ||
                 std::is_same_v<T, float> || std::is_same_v<T, uint64_t> || std::is_same_v<T, double> ||
                 std::is_same_v<T, std::string> || std::is_same_v<T, const char *>
    T getValue() const;
 
    iv::types::channelValue getRawData() const;
    virtual std::string getRawDataUnit() const;
 
    [[nodiscard]] const iv::types::channelId &getChannelId() const;
    [[nodiscard]] iv::types::channelOrder getChannelOrder() const;
    [[nodiscard]] const iv::channels::ChannelAlarmParameters &getAlarmParameters() const;
    [[nodiscard]] const std::map<iv::types::networkId, std::shared_ptr<iv::channels::INetworkInfo>> &
    channelsNetwork() const;
 
    [[nodiscard]] bool isWired() const;
    [[nodiscard]] bool isVirtual() const;
    [[nodiscard]] bool isAnalog() const;
    [[nodiscard]] bool isDigital() const;
    [[nodiscard]] bool isString() const;
 
    bool isSerialLine() const;
    bool isAlarmCalculated() const;
    [[nodiscard]] bool hasValue() const;
 
    // Processed gets
    [[nodiscard]] std::string getAlarmIconName() const;
    [[nodiscard]] iv::types::color getColorStateRgb() const;
    [[nodiscard]] iv::alarms::eAlarmPriority getAlarmPriority() const;
    [[nodiscard]] iv::alarms::eAlarmState getAlarmState() const;
    [[nodiscard]] iv::alarms::eAlarmType getAlarmType() const;
    [[nodiscard]] iv::channels::eInhibitionCondition getInhibitionConditionState() const;
    [[nodiscard]] std::weak_ptr<iv::units::Unit> getUnit() const;
 
    [[nodiscard]] virtual std::string getEngineeringUnitsStr() const;
    [[nodiscard]] virtual std::string formatValue() const = 0;
    [[nodiscard]] virtual iv::channels::FormattedValue formattedValue() const = 0;
 
protected:
    AbstractChannel();
    AbstractChannel(const AbstractChannel &other);
 
    bool shouldStoreAlarm(iv::alarms::Alarm &alarm) const;
    virtual iv::types::channelValue setRawData(iv::types::channelValue value);
 
public:
    iv::types::channelId m_tag;
    std::string m_shipyardTag;
    iv::types::channelOrder m_channelOrder;
    bool m_isEnabled;
 
    std::weak_ptr<AbstractChannel> m_inhibitionChannel;
 
    iv::channels::eChannelBaseType m_baseType;
    iv::channels::eChannelSpecificType m_specificType;
 
    iv::channels::eChannelArea m_area;
    iv::channels::ChannelInfo m_info;
    iv::channels::ChannelAlarmParameters m_alarmParameters;
 
    iv::model::diamar::eVerificationStatus m_verificationStatus;
 
    std::map<iv::types::networkId, std::shared_ptr<iv::channels::INetworkInfo>> m_channelsNetwork;
 
    std::mutex m_mutexUpdate;
    std::atomic<iv::channels::Value> m_value;
    std::atomic<iv::alarms::Alarm> m_alarm;
    std::optional<iv::types::networkId> m_networkOrigin {};
    std::optional<iv::types::stationId> m_stationOrigin {};
 
    std::atomic<iv::channels::Value> m_lastReceivedValue;
    std::atomic<iv::alarms::Alarm> m_lastReceivedAlarm;
    std::optional<iv::types::networkId> m_lastNetworkOrigin {};
    std::optional<iv::types::stationId> m_lastStationOrigin {};
 
    std::atomic<bool> m_shouldCalculateAlarm;
 
    std::unique_ptr<iv::channels::controller::AbstractChannel> m_controller;
 
    iv::types::unitId m_idUnit;
    iv::types::indexChannel m_indexChannel;
    iv::types::milliseconds m_deinitTimeout {DefaultValues::deinitTimeout};
 
private:
    struct Keys
    {
        static constexpr std::string_view channelId {"Id"};
        static constexpr std::string_view shipyardTag {"ShipyardTag"};
        static constexpr std::string_view channelOrder {"Order"};
        static constexpr std::string_view isEnabled {"Enabled"};
        static constexpr std::string_view baseType {"BaseType"};
        static constexpr std::string_view specificType {"SpecificType"};
        static constexpr std::string_view area {"Area"};
        static constexpr std::string_view verificationStatus {"VerificationStatus"};
        static constexpr std::string_view idUnit {"IdUnit"};
        static constexpr std::string_view indexChannel {"IndexChannel"};
        static constexpr std::string_view deinitTimeout {"DeinitTimeout"};
    };
    struct DefaultValues
    {
        static constexpr std::string string {};
        static constexpr iv::types::channelId channelId {};
        static constexpr iv::types::channelOrder channelOrder {};
        static constexpr bool isEnabled {true};
        static constexpr std::string baseType {"WiredAnalog"};
        static constexpr std::string specificType {"AnalogInput"};
        static constexpr std::string area {"All"};
        static constexpr std::string verificationStatus {"NotVerified"};
        static constexpr iv::types::unitId idUnit {};
        static constexpr uint16_t indexChannel {UINT16_MAX};
        static constexpr iv::types::milliseconds deinitTimeout {10 * 1000};
    };
    struct Sections
    {
        static constexpr std::string_view dataflow {"DataFlow"};
        static constexpr std::string_view flow {"Flow"};
    };
};
 
template<typename T>
    requires std::is_same_v<T, bool> || std::is_same_v<T, int32_t> || std::is_same_v<T, uint32_t> ||
             std::is_same_v<T, float> || std::is_same_v<T, uint64_t> || std::is_same_v<T, double> ||
             std::is_same_v<T, std::string> || std::is_same_v<T, const char *>
T AbstractChannel::getValue() const
{
    iv::types::channelValue value = m_value.load().value;
 
    if constexpr (std::is_same_v<T, bool>)
    {
        return static_cast<bool>(value);
    }
    else if constexpr (std::is_same_v<T, int32_t>)
    {
        return static_cast<int32_t>(value);
    }
    else if constexpr (std::is_same_v<T, float>)
    {
        return static_cast<float>(value);
    }
    else if constexpr (std::is_same_v<T, double>)
    {
        return value;
    }
    else if constexpr (std::is_same_v<T, std::string>)
    {
        return std::to_string(value);
    }
    else if constexpr (std::is_same_v<T, const char *>)
    {
        const std::string strValue = std::to_string(value);
        return strValue.c_str();
    }
 
    return T(m_value.load().value);
}
 
}// namespace iv::channels
 
#endif//IV_SRC_CHANNELS_ABSTRACTCHANNEL_HPP_