json.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libfits
 * @copyright 2022 ESO - European Southern Observatory
 *
 * @brief Definition of contents from fits/json.hpp
 */
#include <boost/assign.hpp>
#include <boost/range/adaptor/indexed.hpp>
 
#include <daq/error/json.hpp>
#include <daq/fits/json.hpp>
#include <fmt/format.h>
#include <nlohmann/json.hpp>
 
#include <iostream>
 
using Json = nlohmann::json;
using JsonPointer = nlohmann::json_pointer<Json>;
 
namespace daq::fits {
 
namespace {
 
template <class>
inline constexpr bool AlwaysFalseV = false;  // NOLINT
 
template <class T>
T GetMember(Json const& json, char const* name, JsonPointer const& breadcrumb);
 
template <>
std::string
GetMember<std::string>(Json const& json, char const* name, JsonPointer const& breadcrumb) {
    if (!json.contains(name)) {
        throw error::MakeJsonErrorMissingValue<std::invalid_argument>(breadcrumb / name);
    }
    auto const& value_json = json[name];
    if (!value_json.is_string()) {
        throw error::MakeJsonErrorWrongType<std::invalid_argument>(
            breadcrumb / name, "string", value_json.type_name());
    }
    auto value = value_json.get<std::string>();
    if (value.empty()) {
        throw error::MakeJsonError<std::invalid_argument>(breadcrumb / name,
                                                          "empty string is invalid");
    }
    return value;
}
 
/**
 * Parse the JSON object that defines a keyword.
 * It requires that @a obj is a JSON object with the following fields:
 * - name:str
 * - value:bool,str,number
 * - [comment:str] (optional)
 *
 * @pre @a `obj.is_object() == true`
 */
template <class KeywordType>
KeywordType ParseKeywordObject(Json const& obj, JsonPointer const& breadcrumb) {
    if (!obj.is_object()) {
        throw error::MakeJsonErrorWrongType<std::invalid_argument>(
            breadcrumb, "object", obj.type_name());
    }
 
    auto name = GetMember<std::string>(obj, "name", breadcrumb);
    if (!obj.contains("value")) {
        throw error::MakeJsonErrorMissingValue<std::invalid_argument>(breadcrumb);
    }
 
    typename KeywordType::ValueType kw_value;
    auto const& value = obj["value"];
    if (value.is_boolean()) {
        kw_value = value.get<bool>();
    } else if (value.is_string()) {
        kw_value = value.get<std::string>();
    } else if (value.is_number_float()) {
        kw_value = value.get<double>();
    } else if (value.is_number_unsigned()) {
        kw_value = value.get<uint64_t>();
    } else if (value.is_number_integer()) {
        kw_value = value.get<int64_t>();
    } else {
        throw std::invalid_argument(fmt::format("unsupported type: {}", value.type_name()));
    }
 
    std::optional<std::string> kw_comment;
    if (obj.contains("comment")) {
        auto const& comment = obj["comment"];
        if (!comment.is_string()) {
            throw error::MakeJsonErrorWrongType<std::invalid_argument>(
                breadcrumb / "comment", "string", comment.type_name());
        }
        kw_comment = comment.get<std::string>();
    }
    return KeywordType(name, kw_value, kw_comment);
}
 
template <>
LiteralKeyword ParseKeywordObject<LiteralKeyword>(Json const& obj, JsonPointer const& breadcrumb) {
    assert(obj.is_object());
 
    if (!obj.contains("value")) {
        throw std::invalid_argument("field 'value' missing");
    }
 
    auto const& value = obj["value"];
    if (!value.is_string()) {
        throw std::invalid_argument(
            fmt::format("literalKeyword value must be a string got: {}", value.type_name()));
    }
    auto const& value_str = value.get<std::string>();
    if (value_str.length() > constants::RECORD_LENGTH) {
        throw std::invalid_argument(
            fmt::format("literalKeyword value longer than maximum keyword record. Max: {} got: {}",
                        value_str.length(),
                        constants::RECORD_LENGTH));
    }
    return LiteralKeyword(std::string_view(value_str));
}
 
}  // namespace
 
std::vector<KeywordVariant> ParseJsonKeywords(char const* keywords) {
    // outer value must be an array
    auto parsed = Json::parse(keywords);
    return ParseJsonKeywords(parsed);
}
 
std::vector<KeywordVariant> ParseJsonKeywords(Json const& keywords, JsonPointer const& breadcrumb) {
    using namespace boost::assign;
    using namespace boost::adaptors;
 
    if (!keywords.is_array()) {
        throw error::MakeJsonErrorWrongType<std::invalid_argument>(
            breadcrumb, "array", keywords.type_name());
    }
 
    std::vector<KeywordVariant> parsed_keywords;
    parsed_keywords.reserve(keywords.size());
 
    for (auto const& index : keywords | indexed(0u)) {
        auto const& kw_obj = index.value();
        auto breadcrumb_idx = breadcrumb / index.index();
        if (!kw_obj.is_object()) {
            throw error::MakeJsonErrorWrongType<std::invalid_argument>(
                breadcrumb_idx, "object", kw_obj.type_name());
        }
        auto type = GetMember<std::string>(kw_obj, "type", breadcrumb_idx);
        if (type == "valueKeyword") {
            parsed_keywords.emplace_back(ParseKeywordObject<ValueKeyword>(kw_obj, breadcrumb_idx));
        } else if (type == "esoKeyword") {
            parsed_keywords.emplace_back(ParseKeywordObject<EsoKeyword>(kw_obj, breadcrumb_idx));
        } else if (type == "literalKeyword") {
            parsed_keywords.emplace_back(
                ParseKeywordObject<LiteralKeyword>(kw_obj, breadcrumb_idx));
        } else {
            throw error::MakeJsonErrorUnknownVariant<std::invalid_argument>(
                breadcrumb_idx, "'valueKeyword', 'esoKeyword' or 'literalKeyword'", type.c_str());
        }
    }
 
    return parsed_keywords;
}
 
nlohmann::json SerializeJsonKeywordValue(BasicKeywordBase::ValueType const& value) {
    return std::visit([&](auto const& val) -> Json { return nlohmann::json(val); }, value);
}
 
nlohmann::json SerializeJsonKeyword(KeywordVariant const& keyword) {
    using Json = nlohmann::json;
    return std::visit(
        [&](auto const& kw) -> Json {
            using T = std::decay_t<decltype(kw)>;
            if constexpr (std::is_same_v<T, ValueKeyword>) {
                auto j = Json::object({{"type", "valueKeyword"},
                                       {"name", kw.name},
                                       {"value", SerializeJsonKeywordValue(kw.value)}});
                if (kw.comment) {
                    j["comment"] = *kw.comment;
                }
                return j;
            } else if constexpr (std::is_same_v<T, EsoKeyword>) {
                auto j = Json::object({{"type", "esoKeyword"},
                                       {"name", kw.name},
                                       {"value", SerializeJsonKeywordValue(kw.value)}});
                if (kw.comment) {
                    j["comment"] = *kw.comment;
                }
                return j;
            } else if constexpr (std::is_same_v<T, LiteralKeyword>) {
                return Json::object({{"type", "literalKeyword"}, {"value", kw.GetRecord()}});
            } else {
                static_assert(AlwaysFalseV<T>, "non-exhaustive visitor!");
            }
        },
        keyword);
}
 
nlohmann::json SerializeJsonKeywords(std::vector<KeywordVariant> const& keywords) {
    auto arr = nlohmann::json::array();
    for (auto const& kw : keywords) {
        arr.push_back(SerializeJsonKeyword(kw));
    }
    return arr;
}
 
}  // namespace daq::fits