CEnumParameter.hpp

Go to the documentation of this file.

#ifndef LIBS_CHANNELS_CENUMPARAMETER_HPP_
#define LIBS_CHANNELS_CENUMPARAMETER_HPP_
 
#include "comms/modbus/enums.hpp"
#include "diamar/Cabinets.hpp"
#include "diamar/Groups.hpp"
#include "diamar/Station.hpp"
#include "tanks/Tank.hpp"
#include "units/model/Unit.hpp"
 
class CEnumParameter
{
public:
    //------------- enums and methods related to channels ---------------
 
    // NOTE: UnitId is not part of a channel in the data model, but it's useful having it as part as EParameterChannel
    // to add it in AbstractSheetModel where it's used.
    enum class EParameterChannel
    {
        // COMMON (AbstractChannel)
        Order,           // AbstractChannel::m_channelOrder
        Enable,          // AbstractChannel::m_isEnabled
        BaseType,        // AbstractChannel::m_baseType
        Type,            // AbstractChannel::m_specificType
        Tag,             // AbstractChannel::m_tag
        ShipyardTag,     // AbstractChannel::m_shipyardTag
        InfoDescriptions,// AbstractChannel::m_info.descriptions
        Area,            // AbstractChannel::m_area
        DeInitTimeout,   // AbstractChannel::m_deInitTimeout
 
        // ALARM PARAMETERS (ChannelAlarmParameters)
        AlarmGroupId,            // AbstractChannel::m_alarmParameters.group
        AlarmEnable,             // AbstractChannel::m_alarmParameters.alarmEnabled
        AlarmOffScan,            // AbstractChannel::m_alarmParameters.offScan
        AlarmPriority,           // AbstractChannel::m_alarmParameters.alarmPriority
        AlarmActivationDelay,    // AbstractChannel::m_alarmParameters.activationDelay
        AlarmDeactivationDelay,  // AbstractChannel::m_alarmParameters.deactivationDelay
        AlarmInhibitionTag,      // AbstractChannel::m_alarmParameters.inhibitionChannelTag
        AlarmInhibitionCondition,// AbstractChannel::m_alarmParameters.inhibitionCondition
 
        //DIGITAL
        DigitalInverted,  // DigitalChannel::m_inverted
        DigitalAlarmLimit,// DigitalChannel::m_alarmLimit
        DigitalDelayOn,   // DigitalChannel::m_onDelay
        DigitalDelayOff,  // DigitalChannel::m_offDelay
 
        //ANALOG
        AnalogDeadBand,       // AnalogChannel::m_deadBand
        AnalogOffset,         // AnalogChannel::m_offset
        AnalogFactor,         // AnalogChannel::m_factor
        AnalogNumDecimals,    // AnalogChannel::m_numDecimals
        AnalogMeasurementUnit,// AnalogChannel::m_measurementUnit
        AnalogSensorType,     // AnalogChannel::m_analogSensorType
        AnalogSensorLow,      // AnalogChannel::m_sensorLow
        AnalogSensorHigh,     // AnalogChannel::m_sensorHigh
 
        // ANALOG (ALARM - AnalogAlarmLimits)
        AnalogAlarmIfl,       // AnalogChannel::m_alarmLimits.hasInstrumentFailureLow
        AnalogAlarmIfh,       // AnalogChannel::m_alarmLimits.hasInstrumentFailureHigh
        AnalogAlarmLEL,       // AnalogChannel::m_alarmLimits.lowEngineeringLimit
        AnalogAlarmHEL,       // AnalogChannel::m_alarmLimits.highEngineeringLimit
        AnalogAlarmLLALEnable,// AnalogChannel::m_alarmLimits.lowLowAlarmLimit.hasLimit
        AnalogAlarmLLAL,      // AnalogChannel::m_alarmLimits.lowLowAlarmLimit.limitValue
        AnalogAlarmLALEnable, // AnalogChannel::m_alarmLimits.lowAlarmLimit.hasLimit
        AnalogAlarmLAL,       // AnalogChannel::m_alarmLimits.lowAlarmLimit.limitValue
        AnalogAlarmHALEnable, // AnalogChannel::m_alarmLimits.highAlarmLimit.hasLimit
        AnalogAlarmHAL,       // AnalogChannel::m_alarmLimits.highAlarmLimit.limitValue
        AnalogAlarmHHALEnable,// AnalogChannel::m_alarmLimits.highHighAlarmLimit.hasLimit
        AnalogAlarmHHAL,      // AnalogChannel::m_alarmLimits.highHighAlarmLimit.limitValue
 
        // MISC (ChannelInfo)
        FunctionCode,// AbstractChannel::m_info.functionCode
        Equipment,   // AbstractChannel::m_info.equipment
        System,      // AbstractChannel::m_info.system
 
        UnitId
    };
 
    static std::string getEParameterChannelName(EParameterChannel param, bool shortName = true);
    static uint16_t getEParameterChannelMaxChars(EParameterChannel param);
    static uint16_t getChannelParameterColumnWidth(CEnumParameter::EParameterChannel param);
    static uint16_t getParameterChannelNumberDecimals(EParameterChannel param);
    static bool isEParameterChannelText(EParameterChannel param);
 
    // static methods returning the names of their enumerated value to be shown in the GUI
    // (and vice versa in the case of the verification status)
    static std::string getChannelAreaName(iv::channels::eChannelArea area, bool shortName = true);
    static std::string getChannelSpecificTypeName(iv::channels::eChannelSpecificType type, bool shortName = true);
    static std::string getAlarmPriorityName(iv::alarms::eAlarmPriority priority, bool shortName = true);
    static std::string getDAlarmLimitName(iv::eDigitalValue dAlarmLimit, bool shortName = true);
    static std::string getEngineeringUnitsName(iv::eMeasurementUnit engUnits, bool shortName = true);
    static std::string getInhibitionConditionName(iv::channels::eInhibitionCondition inhibitionCondition,
                                                  bool shortName = true);
    static std::string getSLModbusTypeName(iv::comms::modbus::eFunctionCode slModbusType, bool shortName = true);
    static std::string getSLDataCodificationName(iv::eEndianType slDataCodification, bool shortName = true);
    static std::string getSLDataTypeName(iv::eDataType slDataType, bool shortName = true);
    static std::string getNmea0183FieldTypeName(iv::comms::nmea0183::eFieldType nmeaFieldType, bool shortName = true);
    static std::string getWASensorTypeName(iv::channels::eAnalogSensorType waSensorType, bool shortName = true);
    static std::string getVerificationStatusCSSName(iv::model::diamar::eVerificationStatus verificationStatus);
    static iv::model::diamar::eVerificationStatus getVerificationStatus(const std::string &verificationStatusCSSName);
 
    static std::string getChannelParameterValueAsString(CEnumParameter::EParameterChannel param, iv::eLanguage language,
                                                        const std::shared_ptr<iv::channels::AbstractChannel> &channel,
                                                        bool &isParamValidOut);
 
    static std::string getVerificationStatusTooltip(iv::model::diamar::eVerificationStatus verificationStatus);
    static std::string getChannelAreaTooltip(iv::channels::eChannelArea area);
    static std::string getChannelSpecificTypeTooltip(iv::channels::eChannelSpecificType type);
    static std::string getAlarmPriorityTooltip(iv::alarms::eAlarmPriority priority);
    static std::string getDAlarmLimitTooltip(iv::eDigitalValue dAlarmLimit);
    static std::string getEngineeringUnitsTooltip(iv::eMeasurementUnit engUnits);
    static std::string getInhibitionConditionTooltip(iv::channels::eInhibitionCondition inhibitionCondition);
 
    static std::string getSLDataCodificationTooltip(iv::eEndianType slDataCodification);
    static std::string getSLDataTypeTooltip(iv::eDataType slDataSigned);
    static std::string getWASensorTypeTooltip(iv::channels::eAnalogSensorType waSensorType);
    static std::string getNmea0183FieldTypeTooltip(iv::comms::nmea0183::eFieldType nmeaFieldType);
    static std::string getChannelParameterTooltip(bool markupFormat,
                                                  const std::shared_ptr<iv::channels::AbstractChannel> &channel,
                                                  const std::shared_ptr<iv::units::Unit> &unit,
                                                  CEnumParameter::EParameterChannel param,
                                                  iv::eLanguage language = iv::eLanguage::English);
    static std::string getTankContentTypeTooltip(iv::tanks::eTankContentsType tankContentType);
 
    //------------- enums and methods related to channel's wired parameters ---------------
 
    enum class EParameterChannelWired
    {
        TerminalXT,
        Cable,
        Wire,
        TerminalBoard,
        ShipyardTerminal,
        ShipyardElement,
        First = TerminalXT,
        Last = ShipyardElement
    };
 
    static std::string getEParameterChannelWiredName(EParameterChannelWired param, bool shortName = true);
 
    // static methods returning the names of their enumerated value to be shown in the GUI
    static std::string
    getChannelWiredParameterValueAsString(const std::shared_ptr<iv::channels::AbstractChannel> &channel,
                                          uint32_t rowPosition, EParameterChannelWired param);
 
    static std::string getChannelWiredParameterTooltip(bool markupFormat,
                                                       const std::shared_ptr<iv::channels::AbstractChannel> &channel,
                                                       uint32_t rowPosition, EParameterChannelWired param);
 
    //------------- enums and methods related to units ---------------
 
    enum class EParameterUnit
    {
        UnitId,
        UnitEnabled,
        InternalDescription,
        Cabinet,
        Operational,
        TypeDet,
        SerialNumber,
        FwVersion,
        LogicName,
        LogicVersion,
        DataProjectDate,
    };
 
    static std::string getEParameterUnitName(EParameterUnit param, bool shortName = true);
    static uint16_t getEParameterUnitMaxChars(EParameterUnit param);
 
    static std::string getUnitHeartbeatStateCssName(iv::comms::eHeartbeatState unitEditorState,
                                                    bool isNotInProjectUnit);
 
    enum class eUnitExtraStates
    {
        WrongTypeDetected
    };
    static std::string getUnitExtraStatesCssName(eUnitExtraStates unitExtraState, bool isNotInProjectUnit);
 
    //------------- enums and methods related to units ---------------
 
    enum class EParameterTank
    {
        TankName,
        TankDescription,
        //TankGroup,
        //NameContent,
        Capacity,
        // Thickness, -> Datos de Nereida
        // Permeability, -> Datos de Nereida
        // IsCargo, -> Datos de Nereida
        ContentType,
        Density,
        First = TankName,
        Last = Density,
    };
 
    static std::string getEParameterTankName(EParameterTank param, bool shortName = true);
    static uint16_t getEParameterTankMaxChars(EParameterTank param);
    static uint16_t getEParameterTankNumDecimals(EParameterTank param);
    static std::string getTankParameterValueAsString(const std::weak_ptr<iv::tanks::Tank> &tank,
                                                     CEnumParameter::EParameterTank param, iv::eLanguage language);
 
    //------------- enums and methods related to cabinets ---------------
 
    enum class EParameterCabinets
    {
        CabinetId,
        SerialNumber,
        Location,
        InternalDescription,
    };
 
    static std::string getCabinetParameterName(EParameterCabinets param, bool shortName = true);
    static uint16_t getCabinetParameterMaxChars(EParameterCabinets param);
    static std::string getCabinetParameterValueAsString(const iv::model::diamar::Cabinet &cabinet,
                                                        CEnumParameter::EParameterCabinets param);
 
    //------------- enums and methods related to groups ---------------
 
    enum class EParameterGroups
    {
        GroupId,
        IdForLOMs,
        ShotName,
        LongName,
        Description,
    };
 
    static std::string getGroupParameterName(CEnumParameter::EParameterGroups param, iv::eLanguage language,
                                             bool shortName = true);
    static uint16_t getGroupParameterMaxChars(CEnumParameter::EParameterGroups param);
    static uint16_t getGroupParameterColumnWidth(CEnumParameter::EParameterGroups param);
    static std::string getGroupParameterValueAsString(const iv::model::diamar::Group &group,
                                                      CEnumParameter::EParameterGroups param, iv::eLanguage language);
 
    //------------- enums and methods related to stations ---------------
 
    enum class EParameterStations
    {
        StationId,
        ShipArea,
        CanBlockAck,
        LocalSoundOff,
        AlarmPrinterActive,
        AlarmPrinterDevice,
        PrinterActive,
        PrinterDevice,
        CanConfigureVolume,
        CanConfigureBrightness,
    };
 
    static std::string getStationParameterName(CEnumParameter::EParameterStations param, bool shortName = true);
    static uint16_t getStationParameterMaxChars(CEnumParameter::EParameterStations param);
    static std::string getStationParameterValueAsString(const std::shared_ptr<iv::diamar::Station> &station,
                                                        CEnumParameter::EParameterStations param);
 
    //------------- enums and methods related to units ---------------
 
    enum class EParameterTankCalibrationData
    {
        SoundingHeight,
        Volume,
        // XCG, -> Datos de Nereida
        // YCG, -> Datos de Nereida
        // ZCG, -> Datos de Nereida
        // TransversalInertia, -> Datos de Nereida
        First = SoundingHeight,
        Last = Volume,
    };
 
    static std::string getEParameterTankCalibrationDataName(EParameterTankCalibrationData param, bool shortName = true);
    static uint16_t getEParameterTankCalibrationDataMaxChars(EParameterTankCalibrationData param);
    static uint16_t getEParameterTankCalibrationDataNumDecimals(EParameterTankCalibrationData param);
    static std::string
    getTankCalibrationDataParameterValueAsString(const std::shared_ptr<iv::tanks::SoundingData> &soundingData,
                                                 EParameterTankCalibrationData param);
 
    // static methods returning the names of their enumerated value to be shown in the GUI
    static std::string getUnitTypeName(iv::units::eUnitType type, bool shortName = true, bool shorterName = false);
 
    static std::string getUnitParameterValueAsString(const std::shared_ptr<iv::units::Unit> &unit,
                                                     CEnumParameter::EParameterUnit param);
 
    static std::string getUnitTypeTooltip(iv::units::eUnitType type);
    static std::string getUnitParameterTooltip(bool markupFormat, const std::shared_ptr<iv::units::Unit> &unit,
                                               CEnumParameter::EParameterUnit param);
 
    //------------- enums and methods related to watchcall nodes ---------------
    enum class EParameterWatchcallNodes
    {
        NodeType,
        Names,
        Area,
        isChief,
        isMessRoom,
        Comm,
    };
 
    static std::string getWatchcallNodeParameterName(EParameterWatchcallNodes param, bool shortName = true,
                                                     iv::eLanguage language = iv::eLanguage::English);
    static std::string
    getWatchcallNodeParameterValueAsString(const std::shared_ptr<iv::alarms::WatchcallNode> &watchcallNode,
                                           CEnumParameter::EParameterWatchcallNodes param,
                                           iv::eLanguage language = iv::eLanguage::English);
    static uint16_t getWatchcallParameterMaxChars(EParameterWatchcallNodes param);
};
 
#endif /* LIBS_CHANNELS_CENUMPARAMETER_HPP_ */