status.cpp

Go to the documentation of this file.

#include <algorithm>
#include <daq/status.hpp>
#include <ostream>
 
#include <fmt/format.h>
 
namespace daq {
 
void SetAlert(std::vector<Alert>& alerts, Alert alert) {
    auto it = find(alerts.begin(), alerts.end(), alert);
    if (it != alerts.end()) {
        // Replace
        *it = std::move(alert);
    } else {
        // Or add
        alerts.emplace_back(std::move(alert));
    }
}
 
bool ClearAlert(std::vector<Alert>& alerts, AlertId const& alert) {
    auto it = std::remove(alerts.begin(), alerts.end(), alert);
    if (it != alerts.end()) {
        alerts.erase(it, alerts.end());
        return true;
    }
    return false;
}
 
Alert MakeAlert(std::string_view category, std::string key, std::string description) {
    return Alert{{std::string(category), std::move(key)},
                 std::move(description),
                 Alert::TimePoint::clock::now()};
}
 
Alert MakeAlert(AlertId id, std::string description) {
    return Alert{std::move(id), std::move(description), Alert::TimePoint::clock::now()};
}
 
AlertId MakeAlertId(std::string_view category, std::string key) {
    return AlertId{std::string(category), std::move(key)};
}
 
bool operator==(AlertId const& lhs, AlertId const& rhs) noexcept {
    return lhs.key == rhs.key && lhs.category == rhs.category;
}
 
bool operator!=(AlertId const& lhs, AlertId const& rhs) noexcept {
    return !(lhs == rhs);
}
 
bool operator==(Alert const& lhs, Alert const& rhs) noexcept {
    return lhs.id == rhs.id;
}
 
bool operator==(Alert const& lhs, AlertId const& rhs) noexcept {
    return lhs.id == rhs;
}
 
bool operator==(AlertId const& lhs, Alert const& rhs) noexcept {
    return lhs == rhs.id;
}
 
bool operator!=(Alert const& lhs, Alert const& rhs) noexcept {
    return !(lhs == rhs);
}
 
Status::Status(
    std::string id, std::string file_id, State state, bool error, TimePoint timestamp) noexcept
    : id(std::move(id))
    , file_id(std::move(file_id))
    , state(state)
    , error(error)
    , alerts()
    , timestamp(timestamp) {
}
 
Status::Status(std::string id, std::string file_id) noexcept
    : id(std::move(id))
    , file_id(std::move(file_id))
    , state(State::NotStarted)
    , error(false)
    , alerts()
    , timestamp(TimePoint::clock::now()) {
}
 
bool Status::operator==(Status const& rhs) const noexcept {
    return id == rhs.id && file_id == rhs.file_id && state == rhs.state && error == rhs.error &&
           alerts == rhs.alerts && result == rhs.result;
}
 
bool Status::operator!=(Status const& rhs) const noexcept {
    return !(*this == rhs);
}
 
std::ostream& operator<<(std::ostream& os, Status const& s) {
    os << "Status(id='" << s.id << "', file_id='" << s.file_id << "', state=" << s.state
       << ", error=" << (s.error ? "true" : "false") << ", result='" << s.result << "')";
    return os;
}
 
ObservableStatus::DeferSignal::DeferSignal(ObservableStatus* status) : m_status(status) {
    if (m_status) {
        m_status->DisableSignals();
    }
}
 
ObservableStatus::DeferSignal::DeferSignal(ObservableStatus::DeferSignal&& other) noexcept
    : m_status(nullptr) {
    std::swap(m_status, other.m_status);
}
 
ObservableStatus::DeferSignal&
ObservableStatus::DeferSignal::operator=(ObservableStatus::DeferSignal&& other) noexcept {
    // Reset this before stealing resources from other
    Reset();
 
    std::swap(m_status, other.m_status);
    return *this;
}
 
ObservableStatus::DeferSignal::~DeferSignal() noexcept {
    Reset();
}
 
void ObservableStatus::DeferSignal::Reset() noexcept {
    if (!m_status) {
        return;
    }
    // Signal
    m_status->EnableSignals();
    m_status->SignalChanges(true);
 
    m_status = nullptr;
}
 
ObservableStatus::ObservableStatus(Status status) : m_status(std::move(status)) {
}
 
ObservableStatus::ObservableStatus(std::string id, std::string file_id) noexcept
    : m_status(std::move(id), std::move(file_id)) {
}
 
ObservableStatus& ObservableStatus::operator=(Status const& status) {
    if (m_status == status) {
        return *this;
    }
    if (m_status.id != status.id) {
        throw std::invalid_argument(fmt::format(
            "Precondition not met (equality of DAQ IDs): {} != {}", m_status.id, status.id));
    }
    m_status = status;
    SignalChanges();
    return *this;
}
 
bool ObservableStatus::operator==(ObservableStatus const& rhs) const noexcept {
    return m_status == rhs.m_status;
}
 
bool ObservableStatus::operator!=(ObservableStatus const& rhs) const noexcept {
    return !(*this == rhs);
}
 
bool ObservableStatus::operator==(Status const& rhs) const noexcept {
    return m_status == rhs;
}
 
bool ObservableStatus::operator!=(Status const& rhs) const noexcept {
    return !(*this == rhs);
}
 
std::string const& ObservableStatus::GetId() const noexcept {
    return m_status.id;
}
 
std::vector<Alert> const& ObservableStatus::GetAlerts() const noexcept {
    return m_status.alerts;
}
 
std::string const& ObservableStatus::GetFileId() const noexcept {
    return m_status.file_id;
}
 
State ObservableStatus::GetState() const noexcept {
    return m_status.state;
}
 
bool ObservableStatus::GetError() const noexcept {
    return m_status.error;
}
 
void ObservableStatus::SetState(State s, std::optional<bool> error) noexcept {
    if (s == m_status.state) {
        if (!error || error.value() == m_status.error) {
            return;
        }
    }
    m_status.state = s;
    if (error.has_value()) {
        m_status.error = *error;
    }
    SignalChanges();
}
 
void ObservableStatus::SetError(bool error) noexcept {
    if (error == m_status.error) {
        return;
    }
    m_status.error = error;
    SignalChanges();
}
 
void ObservableStatus::SetResult(std::string result) {
    m_status.result = std::move(result);
    SignalChanges();
}
 
void ObservableStatus::SetAlert(Alert alert) {
    ::daq::SetAlert(m_status.alerts, std::move(alert));
    SignalChanges();
}
 
void ObservableStatus::ClearAlert(AlertId const& alert) {
    if (::daq::ClearAlert(m_status.alerts, alert)) {
        SignalChanges();
    }
}
 
void ObservableStatus::SignalChanges(bool force) noexcept {
    m_status.timestamp = Status::TimePoint::clock::now();
    try {
        if (force || m_deferred_signals == 0) {
            m_signal(*this);
        }
    } catch (...) {
    }
}
 
ObservableStatus::operator Status() const {
    return m_status;
}
 
Status const& ObservableStatus::GetStatus() const noexcept {
    return m_status;
}
 
void ObservableStatus::EnableSignals() noexcept {
    assert(m_deferred_signals > 0);
    --m_deferred_signals;
}
void ObservableStatus::DisableSignals() noexcept {
    ++m_deferred_signals;
}
 
std::ostream& operator<<(std::ostream& os, ObservableStatus const& s) {
    os << "ObservableStatus(id='" << s.GetId() << "', file_id='" << s.GetFileId()
       << "', state=" << s.GetState() << ", error=" << (s.GetError() ? "true" : "false") << ")";
    return os;
}
 
}  // namespace daq