enums.hpp

Go to the documentation of this file.

#ifndef IV_SRC_ALARMS_ENUMS_HPP_
#define IV_SRC_ALARMS_ENUMS_HPP_
 
#include "core/color.hpp"
#include "model/enums.hpp"
 
#include <cstdint>
 
namespace iv::alarms
{
 
enum class eAlarmPriority
{
    Alarm = 0x01,   // Antiguamente 0x02
    Critical = 0x00,// Antiguamente 0x03
    Warning = 0x02  // Antiguamente 0x01
};
 
enum class eAlarmState
{
    Inactive = 0x00,      // No alarm, normal state
    Acknowledged = 0x01,  // Ack
    Active = 0x02,        // Alarm
    Unacknowledged = 0x03,// Return no ack
    Undefined = 0x04,     // No value
};
 
inline uint64_t getAlarmCodeForSlim(const iv::alarms::eAlarmState state)
{
    uint64_t code {0};
 
    switch (state)
    {
        case iv::alarms::eAlarmState::Inactive:
        case iv::alarms::eAlarmState::Undefined:
            code = 0;
            break;
 
        case iv::alarms::eAlarmState::Acknowledged:
            code = 1;
            break;
 
        case iv::alarms::eAlarmState::Active:
            code = 2;
            break;
 
        case iv::alarms::eAlarmState::Unacknowledged:
            code = 3;
            break;
    }
 
    return code;
}
 
enum class eAlarmType
{
    Normal = 0x00,
    AlarmOpen = 0x01,
    AlarmClose = 0x02,
    AlarmIfh = 0x03,
    AlarmHh = 0x04,
    AlarmH = 0x05,
    AlarmL = 0x06,
    AlarmLl = 0x07,
    AlarmIfl = 0x08,
    AlarmOffScan = 0x09,
    AlarmFail = 0x0A,
    AlarmInh = 0x0B,
    AlarmUnk = 0x0C,
};
 
enum class eIsNodeOnDuty : uint8_t
{
    NoOnDuty = 0x00,
    OnDuty = 0x01
};
 
enum class eCallAllStatus
{
    CallAllOff = 0x00,
    CallFromEcr = 0x01,
    CallFromBridge = 0x02,
    CallAllUndefined = 0xFF
};
 
enum class eWatchState : uint8_t
{
    EcrOnWatch = 0x01,
    EcrRequestingEcrOnWatch = 0x18,
    EcrRequestingBgrOnWatch = 0x12 /*ECR requesting BRGOnWatch*/,
    BgrRequestingEcrOnWatch = 0x28 /*BRG requesting ECROnWatch*/,
    BgrRequestingBgrOnWatch = 0x22 /*BRG requesting BRGOnWatch*/,
    BgrOnWatch = 0x04 /*BRGOnWatch*/,
    Undefined = 0x30
};
 
enum class eWatchCmd : uint8_t
{
    EcrButtonPressed = 0x0,
    BrgButtonPressed = 0x1
};
 
enum class eAlarmRepeatType
{
    NoAlarmRepeat = 0x00,
    OnlyDutyAlarmRepeat = 0x01,
    OnDutyAndChiefAlarmRepeat = 0x02,
    AllAlarmRepeat = 0x03
};
 
enum class eWatchcallTechnology
{
    WatchcallNT = 0x00,
    WatchcallCan = 0x01
};
 
inline bool isStateAlarmWithPermission(const iv::alarms::eAlarmState state)
{
    return ((state == iv::alarms::eAlarmState::Active) || (state == iv::alarms::eAlarmState::Unacknowledged));
}
 
inline iv::types::color getAlarmColor(iv::alarms::eAlarmState state, iv::alarms::eAlarmType type,
                                      iv::alarms::eAlarmPriority priority)
{
 
    if (type == iv::alarms::eAlarmType::AlarmInh)
    {
        return iv::color::SedniInhibition;
    }
 
    switch (state)
    {
        case iv::alarms::eAlarmState::Active:
        case iv::alarms::eAlarmState::Acknowledged:
            switch (priority)
            {
                case iv::alarms::eAlarmPriority::Critical:
                    return iv::color::SedniAlarm;
                case iv::alarms::eAlarmPriority::Alarm:
                    if (type == iv::alarms::eAlarmType::AlarmH or type == iv::alarms::eAlarmType::AlarmL)
                    {
                        return iv::color::SedniWarning;
                    }
                    return iv::color::SedniAlarm;
                case iv::alarms::eAlarmPriority::Warning:
                    return iv::color::SedniWarning;
            }
            break;
 
        case iv::alarms::eAlarmState::Unacknowledged:
            return iv::color::SedniUnacknowledgedAlarm;
 
        case iv::alarms::eAlarmState::Undefined:
            return iv::color::SedniNoConnection;
 
        case iv::alarms::eAlarmState::Inactive:
            return iv::color::SedniNoAlarm;
    }
 
    return iv::color::Silver;
}
 
inline std::string getAlarmIcon(const iv::alarms::eAlarmState state, const iv::alarms::eAlarmType type,
                                const iv::alarms::eAlarmPriority priority)
{
    static constexpr std::string resourceRoute {"diamar/"};
    switch (type)
    {
        case iv::alarms::eAlarmType::AlarmOffScan:
            return resourceRoute + "Icon-Offscan";
 
        case iv::alarms::eAlarmType::AlarmInh:
            return resourceRoute + "Icon-Inhibited";
 
        default:
            break;
    }
 
    auto iconPath = resourceRoute + "Icon-Offline";
 
    switch (state)
    {
        case iv::alarms::eAlarmState::Undefined:
        case iv::alarms::eAlarmState::Inactive:
            iconPath = resourceRoute + "Icon-Transparent";//"Icon-Normal";
            break;
 
        case iv::alarms::eAlarmState::Acknowledged:
            if (priority == iv::alarms::eAlarmPriority::Warning)
            {
                iconPath = resourceRoute + "Icon-WarningACK";
            }
            else
            {
                iconPath = resourceRoute + "Icon-AlarmACK";
            }
            break;
 
        case iv::alarms::eAlarmState::Active:
            if (priority == iv::alarms::eAlarmPriority::Warning)
            {
                iconPath = resourceRoute + "Icon-Warning";
            }
            else
            {
                iconPath = resourceRoute + "Icon-Alarm";
            }
            break;
 
        case iv::alarms::eAlarmState::Unacknowledged:
            iconPath = resourceRoute + "Icon-ReturnNoACK";
            break;
    }
 
    return iconPath;
}
 
inline std::string toString(const eAlarmType type)
{
    switch (type)
    {
        case eAlarmType::Normal:
            return "Normal";
        case eAlarmType::AlarmOpen:
            return "OP";
        case eAlarmType::AlarmClose:
            return "CL";
        case eAlarmType::AlarmIfh:
            return "IFH";
        case eAlarmType::AlarmHh:
            return "HHAL";
        case eAlarmType::AlarmH:
            return "HAL";
        case eAlarmType::AlarmL:
            return "LAL";
        case eAlarmType::AlarmLl:
            return "LLAL";
        case eAlarmType::AlarmIfl:
            return "IFL";
        case eAlarmType::AlarmOffScan:
            return "OffScan";
        case eAlarmType::AlarmFail:
            return "Fail";
        case eAlarmType::AlarmInh:
            return "INH";
        case eAlarmType::AlarmUnk:
        default:
            return "Unknown";
    }
}
 
inline std::pair<iv::alarms::eAlarmState, iv::alarms::eAlarmPriority>
getHigherPreference(iv::alarms::eAlarmState previousState, iv::alarms::eAlarmPriority previousPriority,
                    iv::alarms::eAlarmState newState, iv::alarms::eAlarmPriority newPriority)
{
    iv::alarms::eAlarmState resultState {previousState};
    iv::alarms::eAlarmPriority resultPriority {previousPriority};
 
    if (previousState == newState)
    {
        if (newPriority < previousPriority)
        {
            resultPriority = newPriority;
        }
    }
    else
    {
        switch (newState)
        {
            case iv::alarms::eAlarmState::Active:
                resultState = newState;
                resultPriority = newPriority;
                break;
 
            case iv::alarms::eAlarmState::Unacknowledged:
                switch (previousState)
                {
                    case iv::alarms::eAlarmState::Active:
                        break;
 
                    default:
                        resultState = newState;
                        resultPriority = newPriority;
                }
                break;
 
            case iv::alarms::eAlarmState::Acknowledged:
                switch (previousState)
                {
                    case iv::alarms::eAlarmState::Inactive:
                    case iv::alarms::eAlarmState::Undefined:
                        resultState = newState;
                        resultPriority = newPriority;
                        break;
 
                    default:
                        break;
                }
                break;
 
            case iv::alarms::eAlarmState::Inactive:
            case iv::alarms::eAlarmState::Undefined:
                break;
        }
    }
 
    return {resultState, resultPriority};
}
 
inline std::string callAllStatusToString(iv::alarms::eCallAllStatus callAllStatus)
{
    switch (callAllStatus)
    {
        case iv::alarms::eCallAllStatus::CallAllOff:
        case iv::alarms::eCallAllStatus::CallAllUndefined:
            return _("Call All");
        case iv::alarms::eCallAllStatus::CallFromEcr:
            return _("Call All from ECR");
        case iv::alarms::eCallAllStatus::CallFromBridge:
            return _("Call All From BRG");
        default:
            return "Unknown";
    }
}
 
inline std::string watchBrgEcrButtonStatusText(iv::model::eShipArea shipArea, iv::alarms::eWatchState watchState,
                                               iv::alarms::eWatchCmd watchCmd)
{
    switch (shipArea)
    {
        case iv::model::eShipArea::Ecr:
            switch (watchState)
            {
                case iv::alarms::eWatchState::BgrOnWatch:
                    switch (watchCmd)
                    {
                        case iv::alarms::eWatchCmd::EcrButtonPressed:
                            return _("Request ECR");
                        case iv::alarms::eWatchCmd::BrgButtonPressed:
                            return _("BRG");
                    }
                    break;
 
                case iv::alarms::eWatchState::EcrOnWatch:
                    switch (watchCmd)
                    {
                        case iv::alarms::eWatchCmd::EcrButtonPressed:
                            return _("ECR");
                        case iv::alarms::eWatchCmd::BrgButtonPressed:
                            return _("Request BRG");
                    }
                    break;
 
                case iv::alarms::eWatchState::BgrRequestingBgrOnWatch:
                    switch (watchCmd)
                    {
                        case iv::alarms::eWatchCmd::EcrButtonPressed:
                            return _("ECR");
                        case iv::alarms::eWatchCmd::BrgButtonPressed:
                            return _("Accept BRG");
                    }
                    break;
 
                case iv::alarms::eWatchState::BgrRequestingEcrOnWatch:
                    switch (watchCmd)
                    {
                        case iv::alarms::eWatchCmd::EcrButtonPressed:
                            return _("Accept ECR");
                        case iv::alarms::eWatchCmd::BrgButtonPressed:
                            return _("BRG");
                    }
                    break;
 
                case iv::alarms::eWatchState::EcrRequestingBgrOnWatch:
                    switch (watchCmd)
                    {
                        case iv::alarms::eWatchCmd::EcrButtonPressed:
                            return _("ECR");
                        case iv::alarms::eWatchCmd::BrgButtonPressed:
                            return _("Requesting BRG");
                    }
                    break;
 
                case iv::alarms::eWatchState::EcrRequestingEcrOnWatch:
                    switch (watchCmd)
                    {
                        case iv::alarms::eWatchCmd::EcrButtonPressed:
                            return _("Requesting ECR");
                        case iv::alarms::eWatchCmd::BrgButtonPressed:
                            return _("BRG");
                    }
                    break;
 
                case iv::alarms::eWatchState::Undefined:
                default:
                    break;
            }
            break;
 
        case iv::model::eShipArea::Bridge:
            switch (watchState)
            {
                case iv::alarms::eWatchState::BgrOnWatch:
                    switch (watchCmd)
                    {
                        case iv::alarms::eWatchCmd::EcrButtonPressed:
                            return _("Request ECR");
                        case iv::alarms::eWatchCmd::BrgButtonPressed:
                            return _("BRG");
                    }
                    break;
 
                case iv::alarms::eWatchState::EcrOnWatch:
                    switch (watchCmd)
                    {
                        case iv::alarms::eWatchCmd::EcrButtonPressed:
                            return _("ECR");
                        case iv::alarms::eWatchCmd::BrgButtonPressed:
                            return _("Request BRG");
                    }
                    break;
 
                case iv::alarms::eWatchState::BgrRequestingBgrOnWatch:
                    switch (watchCmd)
                    {
                        case iv::alarms::eWatchCmd::EcrButtonPressed:
                            return _("ECR");
                        case iv::alarms::eWatchCmd::BrgButtonPressed:
                            return _("Requesting BRG");
                    }
                    break;
 
                case iv::alarms::eWatchState::BgrRequestingEcrOnWatch:
                    switch (watchCmd)
                    {
                        case iv::alarms::eWatchCmd::EcrButtonPressed:
                            return _("Requesting ECR");
                        case iv::alarms::eWatchCmd::BrgButtonPressed:
                            return _("BRG");
                    }
                    break;
 
                case iv::alarms::eWatchState::EcrRequestingBgrOnWatch:
                    switch (watchCmd)
                    {
                        case iv::alarms::eWatchCmd::EcrButtonPressed:
                            return _("ECR");
                        case iv::alarms::eWatchCmd::BrgButtonPressed:
                            return _("Accept BRG");
                    }
                    break;
 
                case iv::alarms::eWatchState::EcrRequestingEcrOnWatch:
                    switch (watchCmd)
                    {
                        case iv::alarms::eWatchCmd::EcrButtonPressed:
                            return _("Accept ECR");
                        case iv::alarms::eWatchCmd::BrgButtonPressed:
                            return _("BRG");
                    }
                    break;
 
                case iv::alarms::eWatchState::Undefined:
                default:
                    break;
            }
            break;
 
        case iv::model::eShipArea::Accommodation:
        default:
            switch (watchCmd)
            {
                case iv::alarms::eWatchCmd::EcrButtonPressed:
                    return _("ECR");
                case iv::alarms::eWatchCmd::BrgButtonPressed:
                    return _("BRG");
            }
            break;
    }
 
    return _("undefined");
}
 
}// namespace iv::alarms
 
#endif//IV_SRC_ALARMS_ENUMS_HPP_