structs.hpp

Go to the documentation of this file.

#ifndef IV_SRC_ALARMS_STRUCTS_HPP_
#define IV_SRC_ALARMS_STRUCTS_HPP_
 
#include "alarms/enums.hpp"
#include "comms/apis/structs.hpp"
#include "core/Timestamp.hpp"
#include "core/constants.hpp"
#include "core/defines.hpp"
#include "model/structs.hpp"
#include "third_party/magic_enum/magic_enum.hpp"
 
namespace iv::alarms
{
 
struct Alarm
{
    //Overload operator << for std::cout
    friend std::ostream &operator<<(std::ostream &os, const Alarm &alarm)
    {
        os << "Priority: " << magic_enum::enum_name(alarm.alarmPriority)
           << " State: " << magic_enum::enum_name(alarm.alarmState)
           << " Type: " << magic_enum::enum_name(alarm.alarmType) << " Value: " << alarm.value
           << " Timestamp: " << alarm.timestamp;
        return os;
    }
 
    iv::alarms::eAlarmPriority alarmPriority {iv::alarms::eAlarmPriority::Alarm};
    iv::alarms::eAlarmState alarmState {iv::alarms::eAlarmState::Undefined};
    iv::alarms::eAlarmType alarmType {iv::alarms::eAlarmType::Normal};
    iv::types::channelValue value {iv::constants::channelValueInvalid};
    iv::types::timestamp timestamp {0};
    bool hasValidAlarm {false};
};
 
struct Event
{
    Event() = default;
    Event(std::string _tag, std::string _message, const iv::alarms::Alarm &_alarm, const bool _isPrinted = false)
        : tag(std::move(_tag)), message(std::move(_message)), alarm(_alarm), isPrinted(_isPrinted)
    {
    }
    Event(const Event &other) = default;
 
    Event &operator=(const Event &other) = default;
 
    // Comparison operator for std::find
    bool operator==(const Event &other) const
    {
        return tag == other.tag;
    }
 
    // Comparison operator for std::sort
    bool operator<(const Event &other) const
    {
        return std::tie(alarm.timestamp, tag) > std::tie(other.alarm.timestamp, other.tag);
    }
 
    //Overload operator << for std::cout
    friend std::ostream &operator<<(std::ostream &os, const Event &event)
    {
        os << "Tag: " << event.tag << " Message: " << event.message << " Alarm[ " << event.alarm << " ]";
        return os;
    }
 
    iv::types::channelId tag;
    std::string message;
    iv::alarms::Alarm alarm;
    bool isPrinted {false};
};
 
struct FilterHistory
{
    struct GroupFilter
    {
        iv::types::groupId groupId;
        std::string name;
        bool isActive;
    };
 
    struct UnitFilter
    {
        iv::types::unitId id;
        bool isActive;
    };
 
    bool hasStartDate {false};
    bool hasEndDate {false};
    iv::types::timestamp startDate {0};
    iv::types::timestamp endDate {iv::time::Timestamp().inMilliseconds()};
 
    bool hasTags {false};
    std::vector<iv::types::channelId> channelsTags {9};
    bool hasGroups {false};
    std::vector<GroupFilter> groups;
    bool hasUnitsIds {false};
    std::vector<UnitFilter> unitsIds;
 
    iv::comms::api::ApiPaginationInfo paginationInfo;
};
 
struct watchcallNodeStatus
{
    watchcallNodeStatus()
        : isThisNodeOnDuty(iv::alarms::eIsNodeOnDuty::NoOnDuty), dutyState(iv::alarms::eWatchState::Undefined),
          callAllStatus(iv::alarms::eCallAllStatus::CallAllUndefined),
          alarmRepeatType(iv::alarms::eAlarmRepeatType::NoAlarmRepeat)
    {
    }
 
    watchcallNodeStatus(iv::alarms::eIsNodeOnDuty _isThisStationOnDuty, iv::alarms::eWatchState _dutyState,
                        iv::alarms::eCallAllStatus callAll, iv::alarms::eAlarmRepeatType _alarmRepeatType)
        : isThisNodeOnDuty(_isThisStationOnDuty), dutyState(_dutyState), callAllStatus(callAll),
          alarmRepeatType(_alarmRepeatType)
    {
    }
 
    iv::alarms::eIsNodeOnDuty isThisNodeOnDuty;
    iv::alarms::eWatchState dutyState;
    iv::alarms::eCallAllStatus callAllStatus;
    iv::alarms::eAlarmRepeatType alarmRepeatType;
};
 
}// namespace iv::alarms
 
#endif//IV_SRC_ALARMS_STRUCTS_HPP_