structs.hpp

Go to the documentation of this file.

#ifndef IV_SRC_CHANNELS_STRUCTS_HPP_
#define IV_SRC_CHANNELS_STRUCTS_HPP_
 
#include "channels/enums.hpp"
#include "comms/canJ1939/enums.hpp"
#include "comms/modbus/defines.hpp"
#include "core/constants.hpp"
#include "core/defines.hpp"
#include "core/enums.hpp"
#include "filehandlers/xmlFile.hpp"
#include "model/structs.hpp"
#include "third_party/magic_enum/magic_enum.hpp"
 
#include <string>
#include <utility>
 
namespace iv::channels
{
 
struct FormattedValue
{
    std::string value;
    std::optional<std::string> unit;
};
 
struct AnalogAlarmLimit
{
    bool hasLimit {false};
    iv::types::channelValue limitValue {0};
};
 
struct AnalogAlarmLimits
{
    bool hasInstrumentFailureHigh {false};
    bool hasInstrumentFailureLow {false};
    iv::types::channelValue lowEngineeringLimit {0};
    iv::types::channelValue highEngineeringLimit {100};
    iv::channels::AnalogAlarmLimit lowLowAlarmLimit;
    iv::channels::AnalogAlarmLimit lowAlarmLimit;
    iv::channels::AnalogAlarmLimit highAlarmLimit;
    iv::channels::AnalogAlarmLimit highHighAlarmLimit;
};
 
struct ChannelInfo
{
    ChannelInfo() : system(), equipment(), functionCode(), descriptions()
    {
    }
 
    ChannelInfo(const iv::channels::ChannelInfo &other) = default;
    ChannelInfo(const iv::channels::ChannelInfo &&other) = delete;
    ~ChannelInfo() = default;
 
    ChannelInfo &operator=(const iv::channels::ChannelInfo &other)
    {
        if (&other == this)
        {
            return *this;
        }
 
        system = other.system;
        equipment = other.equipment;
        functionCode = other.functionCode;
        descriptions = other.descriptions;
 
        return *this;
    }
 
    ChannelInfo &operator=(const iv::channels::ChannelInfo &&other) = delete;
 
    bool load(const iv::file::xml::node &nodeChannel)
    {
        bool result {true};
        iv::file::xml::node nodeChannelMisc = nodeChannel.getChild(Sections::channelMisc);
        system = nodeChannelMisc.getAttribute(Keys::system, DefaultValues::string);
        equipment = nodeChannelMisc.getAttribute(Keys::equipment, DefaultValues::string);
        functionCode = nodeChannelMisc.getAttribute(Keys::functionCode, DefaultValues::string);
 
        iv::file::xml::node nodeChannelDescriptions = nodeChannel.getChild(Sections::descriptions);
        result &= descriptions.load(nodeChannelDescriptions);
        return result;
    }
 
    bool save(iv::file::xml::node &nodeChannel) const
    {
        bool result {true};
        iv::file::xml::node nodeChannelMiscInfo = nodeChannel.appendChild(Sections::channelMisc);
        nodeChannelMiscInfo.addAttribute(Keys::system, system);
        nodeChannelMiscInfo.addAttribute(Keys::equipment, equipment);
        nodeChannelMiscInfo.addAttribute(Keys::functionCode, functionCode);
 
        iv::file::xml::node nodeChannelDescriptions = nodeChannel.appendChild(Sections::descriptions);
        result &= descriptions.save(nodeChannelDescriptions, Sections::description);
        return result;
    }
 
    std::string system;
    std::string equipment;
    std::string functionCode;
    iv::model::LocalizedText descriptions;
 
private:
    struct Keys
    {
        static constexpr std::string_view system {"System"};
        static constexpr std::string_view equipment {"Equipment"};
        static constexpr std::string_view functionCode {"FunctionCode"};
    };
    struct Sections
    {
        static constexpr std::string_view channelMisc {"Misc"};
        static constexpr std::string_view descriptions {"Descriptions"};
        static constexpr std::string_view description {"Description"};
    };
    struct DefaultValues
    {
        static constexpr std::string string {};
        static constexpr iv::eLanguage language {};
    };
};
 
struct ChannelAlarmParameters
{
    ChannelAlarmParameters()
        : alarmEnabled(DefaultValues::alarmEnabled), offScan(DefaultValues::offScan), group(DefaultValues::group),
          alarmPriority(magic_enum::enum_cast<iv::alarms::eAlarmPriority>(DefaultValues::alarmPriority).value()),
          activationDelay(DefaultValues::activationDelay), deactivationDelay(DefaultValues::deactivationDelay),
          inhibitionChannelTag(DefaultValues::inhibitionChannel),
          inhibitionCondition(DefaultValues::inhibitionCondition)
    {
    }
 
    ChannelAlarmParameters(const ChannelAlarmParameters &other) = default;
 
    ChannelAlarmParameters(ChannelAlarmParameters &&other) noexcept
        : alarmEnabled(other.alarmEnabled), offScan(other.offScan), group(std::move(other.group)),
          alarmPriority(other.alarmPriority), activationDelay(other.activationDelay),
          deactivationDelay(other.deactivationDelay), inhibitionChannelTag(std::move(other.inhibitionChannelTag)),
          inhibitionCondition(other.inhibitionCondition)
    {
    }
 
    ~ChannelAlarmParameters() = default;
 
    ChannelAlarmParameters &operator=(const ChannelAlarmParameters &other)
    {
        alarmEnabled = other.alarmEnabled;
        offScan = other.offScan;
        group = other.group;
        alarmPriority = other.alarmPriority;
        activationDelay = other.activationDelay;
        deactivationDelay = other.deactivationDelay;
        inhibitionChannelTag = other.inhibitionChannelTag;
 
        return *this;
    }
 
    ChannelAlarmParameters &operator=(ChannelAlarmParameters &&other) noexcept
    {
        if (this != &other)
        {
            alarmEnabled = other.alarmEnabled;
            offScan = other.offScan;
            group = std::move(other.group);
            alarmPriority = other.alarmPriority;
            activationDelay = other.activationDelay;
            deactivationDelay = other.deactivationDelay;
            inhibitionChannelTag = std::move(other.inhibitionChannelTag);
        }
 
        return *this;
    }
 
    bool load(const iv::file::xml::node &nodeChannel)
    {
        iv::file::xml::node nodeAlarmParameters = nodeChannel.getChild(Sections::alarmParameters);
        alarmEnabled = nodeAlarmParameters.getAttribute(Keys::alarmEnabled, DefaultValues::alarmEnabled);
        offScan = nodeAlarmParameters.getAttribute(Keys::offScan, DefaultValues::offScan);
        group = nodeAlarmParameters.getAttribute(Keys::group, DefaultValues::group);
        auto aux_alarmPriority = magic_enum::enum_cast<iv::alarms::eAlarmPriority>(
                nodeAlarmParameters.getAttribute(Keys::alarmPriority, DefaultValues::string));
        if (aux_alarmPriority.has_value())
        {
            alarmPriority = aux_alarmPriority.value();
        }
        else
        {
            return false;
        }
        activationDelay = nodeAlarmParameters.getAttribute(Keys::activationDelay, DefaultValues::activationDelay);
        deactivationDelay = nodeAlarmParameters.getAttribute(Keys::deactivationDelay, DefaultValues::deactivationDelay);
        inhibitionChannelTag =
                nodeAlarmParameters.getAttribute(Keys::inhibitionChannel, DefaultValues::inhibitionChannel);
        inhibitionCondition =
                magic_enum::enum_cast<iv::channels::eInhibitionCondition>(
                        nodeAlarmParameters.getAttribute(Keys::inhibitionCondition, DefaultValues::string))
                        .value_or(DefaultValues::inhibitionCondition);
        return true;
    }
 
    bool save(iv::file::xml::node &nodeChannel) const
    {
        iv::file::xml::node nodeAlarmParameters = nodeChannel.appendChild(Sections::alarmParameters);
        nodeAlarmParameters.addAttribute(Keys::alarmEnabled, alarmEnabled);
        nodeAlarmParameters.addAttribute(Keys::offScan, offScan);
        nodeAlarmParameters.addAttribute(Keys::group, group);
        nodeAlarmParameters.addAttribute(Keys::alarmPriority, magic_enum::enum_name(alarmPriority));
        nodeAlarmParameters.addAttribute(Keys::activationDelay, activationDelay);
        nodeAlarmParameters.addAttribute(Keys::deactivationDelay, deactivationDelay);
        nodeAlarmParameters.addAttribute(Keys::inhibitionChannel, inhibitionChannelTag);
        nodeAlarmParameters.addAttribute(Keys::inhibitionCondition, magic_enum::enum_name(inhibitionCondition));
        return true;
    }
 
    [[nodiscard]] std::string strInhibitionChannel() const
    {
        auto txtIHTag = inhibitionChannelTag;
 
        if (not txtIHTag.empty())
        {
            switch (inhibitionCondition)
            {
                case iv::channels::eInhibitionCondition::Close:
                    txtIHTag += ".CL";
                    break;
                case iv::channels::eInhibitionCondition::Open:
                    txtIHTag += ".OP";
                    break;
            }
        }
        else
        {
            txtIHTag = "NINH";
        }
 
        return txtIHTag;
    }
 
    bool alarmEnabled;
    bool offScan;
    iv::types::groupId group {};
    iv::alarms::eAlarmPriority alarmPriority;
    iv::types::delay activationDelay {};
    iv::types::delay deactivationDelay {};
 
    iv::types::channelId inhibitionChannelTag;
    iv::channels::eInhibitionCondition inhibitionCondition;
 
private:
    struct Keys
    {
        static constexpr std::string_view alarmEnabled {"Enabled"};
        static constexpr std::string_view offScan {"OffScan"};
        static constexpr std::string_view group {"Group"};
        static constexpr std::string_view alarmPriority {"Priority"};
        static constexpr std::string_view activationDelay {"ActivationDelay"};
        static constexpr std::string_view deactivationDelay {"DeactivationDelay"};
        static constexpr std::string_view inhibitionChannel {"InhibitionChannel"};
        static constexpr std::string_view inhibitionCondition {"InhibitionCondition"};
    };
    struct Sections
    {
        static constexpr std::string_view alarmParameters {"AlarmParameters"};
    };
    struct DefaultValues
    {
        static constexpr std::string string {};
        static constexpr bool alarmEnabled {false};
        static constexpr bool offScan {false};
        static constexpr iv::types::groupId group {};
        static constexpr std::string alarmPriority {"Alarm"};
        static constexpr iv::types::delay activationDelay {0};
        static constexpr iv::types::delay deactivationDelay {0};
        static constexpr iv::types::channelId inhibitionChannel {};
        static constexpr iv::channels::eInhibitionCondition inhibitionCondition {
                iv::channels::eInhibitionCondition::Close};
    };
};
 
struct J1939Filter
{
    iv::types::comms::spn spn;
    iv::eDataType dataType;
    iv::types::channelValue value;
};
 
struct Nmea2kRegisterInfo
{
    iv::types::comms::pgn pgn {DefaultValues::pgn};
    std::optional<iv::types::comms::j1939SourceAddress> sourceAddress {DefaultValues::sourceAddress};
 
    iv::eDataType dataType {DefaultValues::dataType};
 
    iv::types::comms::nmea2kParameterId parameterId {DefaultValues::parameterId};
 
    std::vector<J1939Filter> filterParameters;
 
    void load(const iv::file::xml::node &nodeRegisterInfo)
    {
        pgn = nodeRegisterInfo.getAttribute(Keys::pgn, DefaultValues::pgn);
 
        int16_t source = nodeRegisterInfo.getAttribute(Keys::sourceAddress, DefaultValues::nullSourceAddress);
        if (source != DefaultValues::nullSourceAddress)
        {
            sourceAddress = source;
        }
        else
        {
            sourceAddress = DefaultValues::sourceAddress;
        }
 
        dataType = magic_enum::enum_cast<iv::eDataType>(
                           nodeRegisterInfo.getAttribute(Keys::dataType, DefaultValues::string))
                           .value_or(DefaultValues::dataType);
 
        parameterId = nodeRegisterInfo.getAttribute(Keys::parameterId, DefaultValues::parameterId);
 
        auto filterParametersNode = nodeRegisterInfo.getChild(Sections::filterParameters);
        for (const auto &filter: filterParametersNode.getChildren())
        {
            iv::types::comms::nmea2kParameterId parameterId =
                    filter.getAttribute(Keys::parameterId, DefaultValues::parameterId);
            iv::eDataType dataType =
                    magic_enum::enum_cast<iv::eDataType>(filter.getAttribute(Keys::dataType, DefaultValues::string))
                            .value_or(DefaultValues::dataType);
            iv::types::channelValue value = filter.getAttribute(Keys::filterValue, 0);
            filterParameters.push_back({parameterId, dataType, value});
        }
    }
 
    void save(iv::file::xml::node &nodeRegisterInfo) const
    {
        nodeRegisterInfo.addAttribute(Keys::pgn, pgn);
 
        if (sourceAddress.has_value())
        {
            nodeRegisterInfo.addAttribute(Keys::sourceAddress, sourceAddress.value());
        }
        else
        {
            nodeRegisterInfo.addAttribute(Keys::sourceAddress, DefaultValues::nullSourceAddress);
        }
 
        nodeRegisterInfo.addAttribute(Keys::dataType, magic_enum::enum_name(dataType));
        nodeRegisterInfo.addAttribute(Keys::parameterId, parameterId);
 
        auto filterParametersNode = nodeRegisterInfo.appendChild(Sections::filterParameters);
        for (const auto &filter: filterParameters)
        {
            iv::file::xml::node filterParameter = filterParametersNode.appendChild(Sections::filterParameter);
            filterParameter.addAttribute(Keys::parameterId, filter.spn);
            filterParameter.addAttribute(Keys::filterValue, filter.value);
            filterParameter.addAttribute(Keys::dataType, magic_enum::enum_name(filter.dataType));
        }
    }
 
private:
    struct Keys
    {
        static constexpr std::string_view pgn {"Pgn"};
        static constexpr std::string_view sourceAddress {"SourceAddress"};
        static constexpr std::string_view dataType {"DataType"};
        static constexpr std::string_view parameterId {"ParameterId"};
        static constexpr std::string_view filterValue {"FilterValue"};
    };
 
    struct Sections
    {
        static constexpr std::string_view filterParameters {"FilterParameters"};
        static constexpr std::string_view filterParameter {"FilterParameter"};
    };
 
public:
    struct DefaultValues
    {
        static constexpr iv::types::comms::pgn pgn {};
        static constexpr std::optional<iv::types::comms::j1939SourceAddress> sourceAddress {std::nullopt};
        static constexpr int16_t nullSourceAddress {-1};
        static constexpr iv::eDataType dataType {iv::eDataType::Int16};
        static constexpr iv::types::comms::nmea2kParameterId parameterId {0};
        static constexpr std::string string {};
    };
};
 
struct J1939RegisterInfo
{
    iv::comms::canJ1939::eJ1939SubProtocol subProtocol {DefaultValues::subProtocol};
 
    iv::types::comms::pgn pgn {DefaultValues::pgn};
    std::optional<iv::types::comms::j1939SourceAddress> sourceAddress {DefaultValues::sourceAddress};
 
    iv::eDataType dataType {DefaultValues::dataType};
 
    iv::types::comms::spn spn {DefaultValues::spn};
    std::vector<J1939Filter> filterSPNs;
 
    //Used in dm1 only
    iv::types::comms::fmi fmi {DefaultValues::fmi};
 
    void load(const iv::file::xml::node &nodeRegisterInfo)
    {
        pgn = nodeRegisterInfo.getAttribute(Keys::pgn, DefaultValues::pgn);
 
        int16_t source = nodeRegisterInfo.getAttribute(Keys::sourceAddress, DefaultValues::nullSourceAddress);
        if (source != DefaultValues::nullSourceAddress)
        {
            sourceAddress = source;
        }
        else
        {
            sourceAddress = DefaultValues::sourceAddress;
        }
 
        spn = nodeRegisterInfo.getAttribute(Keys::spn, DefaultValues::spn);
 
        subProtocol = magic_enum::enum_cast<iv::comms::canJ1939::eJ1939SubProtocol>(
                              nodeRegisterInfo.getAttribute(Keys::subProtocol, DefaultValues::string))
                              .value_or(DefaultValues::subProtocol);
 
        dataType = magic_enum::enum_cast<iv::eDataType>(
                           nodeRegisterInfo.getAttribute(Keys::dataType, DefaultValues::string))
                           .value_or(DefaultValues::dataType);
        auto filterSPNsNode = nodeRegisterInfo.getChild(Sections::filterSPNs);
        for (const auto &filter: filterSPNsNode.getChildren())
        {
            iv::types::comms::spn spn = filter.getAttribute(Keys::spn, DefaultValues::spn);
            iv::eDataType dataType =
                    magic_enum::enum_cast<iv::eDataType>(filter.getAttribute(Keys::dataType, DefaultValues::string))
                            .value_or(DefaultValues::dataType);
            iv::types::channelValue value = filter.getAttribute(Keys::filterValue, 0);
            filterSPNs.push_back({spn, dataType, value});
        }
        fmi = nodeRegisterInfo.getAttribute(Keys::fmi, DefaultValues::fmi);
    }
 
    void save(iv::file::xml::node &nodeRegisterInfo) const
    {
        nodeRegisterInfo.addAttribute(Keys::pgn, pgn);
 
        if (sourceAddress.has_value())
        {
            nodeRegisterInfo.addAttribute(Keys::sourceAddress, sourceAddress.value());
        }
        else
        {
            nodeRegisterInfo.addAttribute(Keys::sourceAddress, DefaultValues::nullSourceAddress);
        }
 
        nodeRegisterInfo.addAttribute(Keys::spn, spn);
        nodeRegisterInfo.addAttribute(Keys::subProtocol, magic_enum::enum_name(subProtocol));
        nodeRegisterInfo.addAttribute(Keys::dataType, magic_enum::enum_name(dataType));
 
        auto filterSPNsNode = nodeRegisterInfo.appendChild(Sections::filterSPNs);
        for (const auto &filter: filterSPNs)
        {
            iv::file::xml::node filterSPN = filterSPNsNode.appendChild(Sections::filterSPN);
            filterSPN.addAttribute(Keys::spn, filter.spn);
            filterSPN.addAttribute(Keys::filterValue, filter.value);
            filterSPN.addAttribute(Keys::dataType, magic_enum::enum_name(filter.dataType));
        }
        nodeRegisterInfo.addAttribute(Keys::fmi, fmi);
    }
 
private:
    struct Keys
    {
        static constexpr std::string_view pgn {"Pgn"};
        static constexpr std::string_view sourceAddress {"SourceAddress"};
        static constexpr std::string_view spn {"Spn"};
        static constexpr std::string_view fmi {"Fmi"};
        static constexpr std::string_view startBit {"StartBit"};
        static constexpr std::string_view length {"Length"};
        static constexpr std::string_view endianType {"EndianType"};
        static constexpr std::string_view direction {"Direction"};
        static constexpr std::string_view subProtocol {"SubProtocol"};
        static constexpr std::string_view dataType {"DataType"};
        static constexpr std::string_view filterValue {"FilterValue"};
    };
 
    struct Sections
    {
        static constexpr std::string_view filterSPNs {"FilterSPNs"};
        static constexpr std::string_view filterSPN {"FilterSPN"};
    };
 
public:
    struct DefaultValues
    {
        static constexpr std::string string {};
        static constexpr std::optional<iv::types::comms::j1939SourceAddress> sourceAddress {std::nullopt};
        static constexpr int16_t nullSourceAddress {-1};
        static constexpr iv::types::comms::pgn pgn {};
        static constexpr iv::types::comms::spn spn {0};
        static constexpr iv::types::comms::fmi fmi {0};
        static constexpr uint8_t startBit {0};
        static constexpr uint8_t length {0};
        static constexpr iv::eEndianType endianType {iv::eEndianType::BigEndian};
        static constexpr iv::comms::eMessageDirection direction {iv::comms::eMessageDirection::Incoming};
        static constexpr iv::comms::canJ1939::eJ1939SubProtocol subProtocol {
                iv::comms::canJ1939::eJ1939SubProtocol::SinglePacket};
        static constexpr iv::eDataType dataType {iv::eDataType::Int64};
    };
};
 
struct ModbusRegisterInfo
{
    iv::comms::modbus::eRegisterType type {DefaultValues::type};
    bool isExtended {DefaultValues::isExtended};
    iv::types::comms::modbus::modbusAddress address {DefaultValues::address};
 
    iv::eDataType dataType {DefaultValues::dataType};
    iv::eEndianType endianType {DefaultValues::endianType};
 
    uint8_t registerBitsLength {DefaultValues::registerBitsLength};
    uint8_t bitPosition {DefaultValues::bitPosition};
 
    iv::types::modbus::slaveId slaveId {0};
 
    void load(const iv::file::xml::node &nodeRegisterInfo)
    {
        type = magic_enum::enum_cast<iv::comms::modbus::eRegisterType>(
                       nodeRegisterInfo.getAttribute(Keys::type, DefaultValues::string))
                       .value_or(DefaultValues::type);
        address = nodeRegisterInfo.getAttribute(Keys::address, DefaultValues::address);
 
        if (nodeRegisterInfo.attribute(Keys::isExtended.data()) != nullptr)
        {
            isExtended = nodeRegisterInfo.getAttribute(Keys::isExtended, DefaultValues::isExtended);
        }
        else
        {
            isExtended = address >= iv::comms::modbus::constants::maxNonExtendedAddress;
        }
 
        dataType = magic_enum::enum_cast<iv::eDataType>(
                           nodeRegisterInfo.getAttribute(Keys::dataType, DefaultValues::string))
                           .value_or(DefaultValues::dataType);
        endianType = magic_enum::enum_cast<iv::eEndianType>(
                             nodeRegisterInfo.getAttribute(Keys::endianType, DefaultValues::string))
                             .value_or(DefaultValues::endianType);
        registerBitsLength = nodeRegisterInfo.getAttribute(Keys::registerBitsLength, DefaultValues::registerBitsLength);
        bitPosition = nodeRegisterInfo.getAttribute(Keys::bitPosition, DefaultValues::bitPosition);
        slaveId = static_cast<unsigned char>(nodeRegisterInfo.getAttribute(Keys::slaveId, 0));
    }
 
    void save(iv::file::xml::node &nodeRegisterInfo) const
    {
        nodeRegisterInfo.addAttribute(Keys::type, magic_enum::enum_name(type));
        nodeRegisterInfo.addAttribute(Keys::isExtended, isExtended);
        nodeRegisterInfo.addAttribute(Keys::address, address);
        nodeRegisterInfo.addAttribute(Keys::dataType, magic_enum::enum_name(dataType));
        nodeRegisterInfo.addAttribute(Keys::endianType, magic_enum::enum_name(endianType));
        nodeRegisterInfo.addAttribute(Keys::registerBitsLength, registerBitsLength);
        nodeRegisterInfo.addAttribute(Keys::bitPosition, bitPosition);
        nodeRegisterInfo.addAttribute(Keys::slaveId, slaveId);
    }
 
private:
    struct Keys
    {
        static constexpr std::string_view registerDirection {"RegisterDirection"};
        static constexpr std::string_view type {"Type"};
        static constexpr std::string_view isExtended {"IsExtended"};
        static constexpr std::string_view address {"Address"};
        static constexpr std::string_view dataType {"DataType"};
        static constexpr std::string_view endianType {"EndianType"};
        static constexpr std::string_view registerBitsLength {"RegisterBitsLength"};
        static constexpr std::string_view bitPosition {"BitPosition"};
        static constexpr std::string_view slaveId {"SlaveId"};
    };
 
    struct DefaultValues
    {
        static constexpr std::string string {};
        static constexpr iv::comms::modbus::eRegisterType type {iv::comms::modbus::eRegisterType::HoldingRegister};
        static constexpr bool isExtended {false};
        static constexpr iv::types::comms::modbus::modbusAddress address {0};
        static constexpr iv::eDataType dataType {iv::eDataType::Int16};
        static constexpr iv::eEndianType endianType {iv::eEndianType::BigEndian};
        static constexpr uint8_t registerBitsLength {16};
        static constexpr uint8_t bitPosition {0};
    };
};
 
struct Nmea0183RegisterInfo
{
    iv::types::comms::nmea0183::nmeaHeader header {DefaultValues::header};
    iv::types::comms::nmea0183::fieldPosition fieldPosition {DefaultValues::fieldPosition};
    iv::comms::nmea0183::eFieldType fieldType {DefaultValues::fieldType};
 
    void load(const iv::file::xml::node &nodeRegisterInfo)
    {
        header = nodeRegisterInfo.getAttribute(Keys::header, DefaultValues::header);
        fieldPosition = nodeRegisterInfo.getAttribute(Keys::fieldPosition, DefaultValues::fieldPosition);
        fieldType = magic_enum::enum_cast<iv::comms::nmea0183::eFieldType>(
                            nodeRegisterInfo.getAttribute(Keys::fieldType, DefaultValues::string))
                            .value_or(DefaultValues::fieldType);
    }
 
    void save(iv::file::xml::node &nodeRegisterInfo) const
    {
        nodeRegisterInfo.addAttribute(Keys::header, header);
        nodeRegisterInfo.addAttribute(Keys::fieldPosition, fieldPosition);
        nodeRegisterInfo.addAttribute(Keys::fieldType, magic_enum::enum_name(fieldType));
    }
 
private:
    struct Keys
    {
        static constexpr std::string_view header {"Header"};
        static constexpr std::string_view fieldPosition {"FieldPosition"};
        static constexpr std::string_view fieldType {"FieldType"};
    };
    struct DefaultValues
    {
        static constexpr std::string string {};
        static constexpr iv::types::comms::nmea0183::nmeaHeader header {};
        static constexpr iv::types::comms::nmea0183::fieldPosition fieldPosition {1};
        static constexpr iv::comms::nmea0183::eFieldType fieldType {iv::comms::nmea0183::eFieldType::Integer};
    };
};
 
struct VdrRegisterInfo
{
    iv::types::comms::vdr::id vdrId {DefaultValues::vdrId};
 
    void load(const iv::file::xml::node &nodeRegisterInfo)
    {
        vdrId = nodeRegisterInfo.getAttribute(Keys::vdrId, DefaultValues::vdrId);
    }
 
    void save(iv::file::xml::node &nodeRegisterInfo) const
    {
        nodeRegisterInfo.addAttribute(Keys::vdrId, vdrId);
    }
 
private:
    struct Keys
    {
        static constexpr std::string_view vdrId {"VdrId"};
    };
 
    struct DefaultValues
    {
        static constexpr iv::types::comms::vdr::id vdrId {0};
    };
};
 
struct WireConnectionData
{
    std::string terminalXT;
    std::string cable;
    std::string wire;
    std::string terminalBoard;
    std::string shipyardTerminal;
    std::string shipyardElement;
};
 
struct Value
{
    bool hasValidValue {false};
    iv::types::channelValue value {iv::constants::channelValueInvalid};
    iv::types::channelValue rawData {iv::constants::channelValueInvalid};
    iv::types::timestamp timestamp {0};
};
 
namespace controller
{
 
}// namespace controller
 
}// namespace iv::channels
 
#endif//IV_SRC_CHANNELS_STRUCTS_HPP_