json.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_common_libdaq
 * @copyright (c) Copyright ESO 2022
 * All Rights Reserved
 * ESO (eso.org) is an Intergovernmental Organisation, and therefore special legal conditions apply.
 *
 * @brief Declares JSON support for serialization
 */
#include <daq/json.hpp>
 
#include <fmt/format.h>
 
#include <daq/daqContext.hpp>
#include <daq/fits/json.hpp>
#include <daq/status.hpp>
 
namespace daq {
 
namespace {
template <class Clock, class Duration>
double MakeTimestamp(std::chrono::time_point<Clock, Duration> const& ts) {
    using Seconds = std::chrono::duration<double, std::ratio<1>>;
    return std::chrono::time_point_cast<Seconds>(ts).time_since_epoch().count();
}
 
template <class Clock, class Duration>
void MakeTimepoint(std::chrono::time_point<Clock, Duration>& ts, double time) {
    using Seconds = std::chrono::duration<double, std::ratio<1>>;
    ts = std::chrono::time_point<Clock, Duration>(
        std::chrono::duration_cast<Duration>(Seconds(time)));
}
 
}  // namespace
 
// NOLINTNEXTLINE
void to_json(nlohmann::json& j, Status const& p) {
    j = nlohmann::json{{"id", p.id},
                       {"fileId", p.file_id},
                       {"state", p.state},
                       {"error", p.error},
                       {"alerts", p.alerts},
                       {"receivers", p.receivers},
                       {"result", p.result},
                       {"timestamp", MakeTimestamp(p.timestamp)}};
}
 
// NOLINTNEXTLINE
void to_json(nlohmann::json& j, Alert const& p) {
    j = nlohmann::json{{"category", p.id.category},
                       {"key", p.id.key},
                       {"description", p.description},
                       {"timestamp", MakeTimestamp(p.timestamp)}};
}
 
// NOLINTNEXTLINE
void to_json(nlohmann::json& j, ReceiverStatus const& p) {
    j = nlohmann::json{{"state", p.state}};
}
 
// NOLINTNEXTLINE
void to_json(nlohmann::json& j, DaqContext const& p) {
    auto kws = fits::SerializeJsonKeywords(p.keywords);
    j = nlohmann::json{
        {"id", p.id},
        {"fileId", p.file_id},
        {"creationTime", std::chrono::nanoseconds(p.creation_time.time_since_epoch()).count()},
        {"processName", p.process_name},
        {"dpNamePrefix", p.dp_name_prefix},
        {"primSources", p.prim_sources},
        {"metaSources", p.meta_sources},
        {"keywords", std::move(kws)},
        {"awaitInterval", p.await_interval.count()},
        {"dpParts", p.results}};
 
    // Optional specification
    if (p.specification) {
        j["specification"] = *p.specification;
    }
}
//
// NOLINTNEXTLINE
void to_json(nlohmann::json& j, DaqContext::Source const& p) {
    j = nlohmann::json{{"name", p.name}, {"rrUri", p.rr_uri}};
}
 
// NOLINTNEXTLINE
void to_json(nlohmann::json& j, DpPart const& p) {
    if (std::holds_alternative<fits::KeywordVector>(p.Part())) {
        // keywords
        auto kws = fits::SerializeJsonKeywords(std::get<fits::KeywordVector>(p.Part()));
        j = nlohmann::json::object(
            {{"type", "fitsKeywords"}, {"sourceName", p.SourceName()}, {"keywords", std::move(kws)}});
    } else if (std::holds_alternative<std::string>(p.Part())) {
        auto const& path = std::get<std::string>(p.Part());
        j = nlohmann::json::object(
            {{"type", "fitsFile"}, {"sourceName", p.SourceName()}, {"location", path}});
    }
}
 
// NOLINTNEXTLINE
void from_json(nlohmann::json const& j, Status& p) {
    j.at("id").get_to(p.id);
    j.at("fileId").get_to(p.file_id);
    j.at("state").get_to(p.state);
    j.at("error").get_to(p.error);
    j.at("alerts").get_to(p.alerts);
    j.at("receivers").get_to(p.receivers);
    j.at("result").get_to(p.result);
    double ts;
    j.at("timestamp").get_to(ts);
    MakeTimepoint(p.timestamp, ts);
}
 
// NOLINTNEXTLINE
void from_json(nlohmann::json const& j, Alert& p) {
    j.at("category").get_to(p.id.category);
    j.at("key").get_to(p.id.key);
    j.at("description").get_to(p.description);
    double ts;
    j.at("timestamp").get_to(ts);
    MakeTimepoint(p.timestamp, ts);
}
 
// NOLINTNEXTLINE
void from_json(nlohmann::json const& j, ReceiverStatus& p) {
    j.at("state").get_to(p.state);
}
 
// NOLINTNEXTLINE
void from_json(nlohmann::json const& j, DaqContext& p) {
    j.at("id").get_to(p.id);
    j.at("fileId").get_to(p.file_id);
    j.at("processName").get_to(p.process_name);
    j.at("dpNamePrefix").get_to(p.dp_name_prefix);
    j.at("primSources").get_to(p.prim_sources);
    j.at("metaSources").get_to(p.meta_sources);
    unsigned interval;
    j.at("awaitInterval").get_to(interval);
    p.await_interval = decltype(p.await_interval)(interval);
    j.at("dpParts").get_to(p.results);
    p.keywords = fits::ParseJsonKeywords(j["keywords"]);
    int64_t time_since_epoch_ns;
    j.at("creationTime").get_to(time_since_epoch_ns);
    using Time = std::chrono::system_clock::time_point;
    p.creation_time = Time(std::chrono::nanoseconds(time_since_epoch_ns));
 
    if (j.contains("specification")) {
        p.specification = json::ParseStartDaqV2Spec(j.at("specification"));
    }
}
 
// NOLINTNEXTLINE
void from_json(nlohmann::json const& j, DaqContext::Source& p) {
    j.at("name").get_to(p.name);
    j.at("rrUri").get_to(p.rr_uri);
}
 
// NOLINTNEXTLINE
void from_json(nlohmann::json const& j, DpPart& p) {
    std::string type;
    std::string name;
    j.at("type").get_to(type);
    j.at("sourceName").get_to(p.SourceName());
 
    if (type == "fitsKeywords") {
        p.Part() = fits::ParseJsonKeywords(j.at("keywords"));
    } else if (type == "fitsFile") {
        std::string path;
        j.at("location").get_to(path);
        p.Part() = path;
    } else {
        throw std::invalid_argument(fmt::format("Invalid type: {}", type));
    }
}
 
}  // namespace daq