status.cpp

Go to the documentation of this file.

#include <algorithm>
#include <daq/status.hpp>
#include <ostream>
 
namespace daq {
 
Status::Status(std::string id,
               State state,
               bool error,
               DpParts files,
               fits::KeywordVector keywords,
               TimePoint timestamp) noexcept
    : id(std::move(id))
    , state(state)
    , error(error)
    , files(std::move(files))
    , keywords(std::move(keywords))
    , timestamp(timestamp) {
}
 
Status::Status(std::string id) noexcept
    : id(std::move(id))
    , state(State::NotStarted)
    , error(false)
    , files()
    , keywords()
    , timestamp(TimePoint::clock::now()) {
}
 
bool Status::operator==(Status const& rhs) const noexcept {
    return id == rhs.id && state == rhs.state && files == rhs.files && keywords == rhs.keywords &&
           error == rhs.error;
}
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 << "', state=" << s.state << ", error="
       << (s.error ? "true" : "false") << ")";
    return os;
}
 
ObservableStatus::ObservableStatus(std::string id) noexcept : m_status(std::move(id)) {
}
 
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;
}
 
State ObservableStatus::GetState() const noexcept {
    return m_status.state;
}
 
bool ObservableStatus::GetError() const noexcept {
    return m_status.error;
}
 
std::vector<DpPart> const& ObservableStatus::GetFiles() const noexcept {
    return m_status.files;
}
 
fits::KeywordVector const& ObservableStatus::GetKeywords() const noexcept {
    return m_status.keywords;
}
 
void ObservableStatus::AddFiles(std::vector<DpPart> const& files) {
    using std::copy;
    copy(files.begin(), files.end(), std::back_inserter(m_status.files));
    SignalChanges();
}
 
void ObservableStatus::UpdateKeywords(fits::KeywordVector const& keywords) noexcept {
    if (keywords.empty()) {
        return;
    }
    fits::UpdateKeywords(m_status.keywords, keywords);
    SignalChanges();
}
 
void ObservableStatus::SetState(State s) noexcept {
    if (s == m_status.state) {
        return;
    }
    m_status.state = s;
    SignalChanges();
}
 
void ObservableStatus::SetError(bool error) noexcept {
    if (error == m_status.error) {
        return;
    }
    m_status.error = error;
    SignalChanges();
}
 
void ObservableStatus::SignalChanges() noexcept {
    m_status.timestamp = Status::TimePoint::clock::now();
    try {
        m_signal(*this);
    } catch (...) {
    }
}
 
ObservableStatus::operator Status() const {
    return m_status;
}
 
Status const& ObservableStatus::GetStatus() const noexcept {
    return m_status;
}
 
std::ostream& operator<<(std::ostream& os, ObservableStatus const& s) {
    os << "ObservableStatus(id='" << s.GetId() << "', state=" << s.GetState() << ", error="
       << (s.GetError() ? "true" : "false") << ")";
    return os;
}
 
}  // namespace daq