conversion.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_libdaq
 * @copyright 2022 ESO - European Southern Observatory
 *
 * @brief Contains definitions for daq/conversion.hpp
 */
#include <daq/conversion.hpp>
#include <fmt/format.h>
#include <string_view>
 
#include <daq/json.hpp>
#include <daq/state.hpp>
#include <daq/status.hpp>
 
#include <daqif/malTypes.hpp>
 
namespace daq {
 
daqif::DaqStatus& operator<<(daqif::DaqStatus& status, daq::Status const& rhs) {
    using Seconds = std::chrono::duration<double, std::ratio<1>>;
    status.setId(rhs.id);
    status.setFileId(rhs.file_id);
    auto full_state = MakeState(rhs.state);
    status.setState(full_state.state);
    status.setSubState(full_state.substate);
    status.setError(HasError(rhs));
    status.setResult(rhs.result);
    status.setTimestamp(
        std::chrono::time_point_cast<Seconds>(rhs.timestamp).time_since_epoch().count());
 
    nlohmann::json j = rhs.alerts;
    status.setMessage(j.dump(2));
 
    return status;
}
 
Status& operator<<(Status& status, daqif::DaqStatus const& rhs) {
    using Seconds = std::chrono::duration<double, std::ratio<1>>;
    status.id = rhs.getId();
    status.file_id = rhs.getFileId();
    status.state = MakeState({rhs.getState(), rhs.getSubState()});
    status.result = rhs.getResult();
    status.timestamp = Status::TimePoint(
        std::chrono::duration_cast<Status::TimePoint::duration>(Seconds(rhs.getTimestamp())));
    return status;
}
 
daqif::InternalDaqStatus& operator<<(daqif::InternalDaqStatus& status, Status const& rhs) {
    nlohmann::json j = rhs;
    status.setPayload(std::make_shared<daqif::Blob>(j.dump(2)));
    return status;
}
 
Status& operator<<(Status& status, daqif::InternalDaqStatus const& rhs) {
    std::string_view sv = AsStringView(*rhs.getPayload());
    auto json = nlohmann::json::parse(std::begin(sv), std::end(sv));
    status = json.get<Status>();
    return status;
}
 
std::filesystem::space_info&
operator<<(std::filesystem::space_info& space, daqif::StorageStatus const& rhs) {
    space.available = rhs.getAvailable();
    space.capacity = rhs.getCapacity();
    space.free = rhs.getFree();
    return space;
}
 
daqif::StorageStatus& operator<<(daqif::StorageStatus& storage, std::filesystem::space_info& rhs) {
    storage.setAvailable(rhs.available);
    storage.setCapacity(rhs.capacity);
    storage.setFree(rhs.free);
    return storage;
}
 
daqif::FullState MakeState(State state) noexcept {
    using namespace daq;
    switch (state) {
    case State::NotStarted:
        return {daqif::StateAcquiring, daqif::NotStarted};
    case State::Starting:
        return {daqif::StateAcquiring, daqif::Starting};
    case State::Acquiring:
        return {daqif::StateAcquiring, daqif::Acquiring};
    case State::Stopping:
        return {daqif::StateAcquiring, daqif::Stopping};
    case State::Stopped:
        return {daqif::StateAcquiring, daqif::Stopped};
    case State::AbortingAcquiring:
        return {daqif::StateAcquiring, daqif::Aborting};
 
    case State::NotScheduled:
        return {daqif::StateMerging, daqif::NotScheduled};
    case State::Scheduled:
        return {daqif::StateMerging, daqif::Scheduled};
    case State::Collecting:
        return {daqif::StateMerging, daqif::Collecting};
    case State::Merging:
        return {daqif::StateMerging, daqif::Merging};
    case State::Releasing:
        return {daqif::StateMerging, daqif::Releasing};
    case State::AbortingMerging:
        return {daqif::StateMerging, daqif::Aborting};
 
    case State::Completed:
        return {daqif::StateCompleted, daqif::Completed};
    case State::Aborted:
        return {daqif::StateCompleted, daqif::Aborted};
    // GCOVR_EXCL_START
    default:
        return {daqif::StateUndefined, daqif::Undefined};
        // GCOVR_EXCL_STOP
    };
}
 
State MakeState(daqif::FullState state) noexcept {
    using namespace daq;
    switch (state.substate) {
    case daqif::NotStarted:
        return State::NotStarted;
    case daqif::Starting:
        return State::Starting;
    case daqif::Acquiring:
        return State::Acquiring;
    case daqif::Stopping:
        return State::Stopping;
    case daqif::Stopped:
        return State::Stopped;
 
    case daqif::NotScheduled:
        return State::NotScheduled;
    case daqif::Scheduled:
        return State::Scheduled;
    case daqif::Collecting:
        return State::Collecting;
    case daqif::Merging:
        return State::Merging;
    case daqif::Releasing:
        return State::Releasing;
 
    case daqif::Completed:
        return State::Completed;
 
    case daqif::Aborting:
        return (state.state == daqif::StateAcquiring) ? State::AbortingAcquiring
                                                      : State::AbortingMerging;
    case daqif::Aborted:
        return State::Aborted;
 
    // GCOVR_EXCL_START
    default:
        fmt::print(
            stderr, "Invalid daqif::DaqSubState value {:d} (undefined behaviour)", state.substate);
        std::abort();
        // GCOVR_EXCL_STOP
    };
}
 
std::string_view ToString(daqif::DaqState state) noexcept {
    using namespace std::string_view_literals;
    switch (state) {
    case daqif::StateAcquiring:
        return "StateAcquiring";
    case daqif::StateMerging:
        return "StateMerging";
    case daqif::StateCompleted:
        return "StateCompleted";
    case daqif::DaqState::StateUndefined:
        [[fallthrough]];
    default:
        return "Undefined";
    };
}
 
std::string_view ToString(daqif::DaqSubState state) noexcept {
    using namespace std::string_view_literals;
    switch (state) {
    case daqif::DaqSubState::NotStarted:
        return "NotStarted";
    case daqif::DaqSubState::Starting:
        return "Starting";
    case daqif::DaqSubState::Acquiring:
        return "Acquiring";
    case daqif::DaqSubState::Stopping:
        return "Stopping";
    case daqif::DaqSubState::Stopped:
        return "Stopped";
    case daqif::DaqSubState::Aborting:
        return "Aborting";
    case daqif::DaqSubState::Aborted:
        return "Aborted";
    case daqif::DaqSubState::NotScheduled:
        return "NotScheduled";
    case daqif::DaqSubState::Scheduled:
        return "Scheduled";
    case daqif::DaqSubState::Collecting:
        return "Collecting";
    case daqif::DaqSubState::Merging:
        return "Merging";
    case daqif::DaqSubState::Releasing:
        return "Releasing";
    case daqif::DaqSubState::Completed:
        return "Completed";
    case daqif::DaqSubState::Undefined:
        [[fallthrough]];
    default:
        return "Undefined";
    };
}
 
}  // namespace daq