conversion.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libocmif_suppport
 * @copyright 2021 ESO - European Southern Observatory
 *
 * @brief Contains definitions for ocmif/conversion.hpp
 */
#include <ocmif/conversion.hpp>
#include <string_view>
#include <fmt/format.h>
 
#include <daq/status.hpp>
#include <daq/state.hpp>
 
namespace ocmif {
 
DaqStatus& operator<<(DaqStatus& status, daq::Status const& rhs) {
    using Seconds = std::chrono::duration<double, std::ratio<1>>;
    status.setId(rhs.id);
    // @todo Refactor interal representation to also cover toplevel state
    status.setState(rhs.state == daq::State::Aborted ? ocmif::StateCompleted
                                                     : ocmif::StateAcquiring);
    status.setSubState(MakeState(rhs.state));
    status.setError(rhs.error);
    status.setTimestamp(
        std::chrono::time_point_cast<Seconds>(rhs.timestamp).time_since_epoch().count());
    status.setMessage("");
 
    return status;
}
 
ocmif::DaqSubState MakeState(daq::State state) noexcept {
    using namespace daq;
    switch (state) {
    case State::NotStarted:
        return ocmif::NotStarted;
    case State::Starting:
        return ocmif::Starting;
    case State::Acquiring:
        return ocmif::Acquiring;
    case State::Stopping:
        return ocmif::Stopping;
    case State::Stopped:
        return ocmif::Stopped;
    case State::Aborting:
        return ocmif::Aborting;
    case State::Aborted:
        return ocmif::Aborted;
    // GCOVR_EXCL_START
    default:
        return ocmif::Undefined;
        // GCOVR_EXCL_STOP
    };
}
 
daq::State MakeState(ocmif::DaqSubState state) {
    using namespace daq;
    switch (state) {
    case ocmif::NotStarted:
        return State::NotStarted;
    case ocmif::Starting:
        return State::Starting;
    case ocmif::Acquiring:
        return State::Acquiring;
    case ocmif::Stopping:
        return State::Stopping;
    case ocmif::Stopped:
        return State::Stopped;
    case ocmif::Aborting:
        return State::Aborting;
    case ocmif::Aborted:
        return State::Aborted;
    default:
        throw std::invalid_argument(fmt::format("Invalid ocmif::DaqSubState value {:d}", state));
    };
}
 
std::string_view ToString(ocmif::DaqState state) noexcept {
    using namespace std::string_view_literals;
    switch (state) {
    case ocmif::StateAcquiring:
        return "StateAcquiring";
    case ocmif::StateMerging:
        return "StateMerging";
    case ocmif::StateCompleted:
        return "StateCompleted";
    case ocmif::DaqState::StateUndefined:
        [[fallthrough]];
    default:
        return "Undefined";
    };
}
 
std::string_view ToString(ocmif::DaqSubState state) noexcept {
    using namespace std::string_view_literals;
    switch (state) {
    case ocmif::DaqSubState::NotStarted:
        return "NotStarted";
    case ocmif::DaqSubState::Starting:
        return "Starting";
    case ocmif::DaqSubState::Acquiring:
        return "Acquiring";
    case ocmif::DaqSubState::Stopping:
        return "Stopping";
    case ocmif::DaqSubState::Stopped:
        return "Stopped";
    case ocmif::DaqSubState::Aborting:
        return "Aborting";
    case ocmif::DaqSubState::Aborted:
        return "Aborted";
    case ocmif::DaqSubState::NotScheduled:
        return "NotScheduled";
    case ocmif::DaqSubState::Scheduled:
        return "Scheduled";
    case ocmif::DaqSubState::Transferring:
        return "Transferring";
    case ocmif::DaqSubState::Merging:
        return "Merging";
    case ocmif::DaqSubState::Releasing:
        return "Releasing";
    case ocmif::DaqSubState::Completed:
        return "Completed";
    case ocmif::DaqSubState::Undefined:
        [[fallthrough]];
    default:
        return "Undefined";
    };
}
 
}  // namespace ocmif