json.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_libfits
 * @copyright 2021 ESO - European Southern Observatory
 *
 * @brief Definition of contents from fits/json.hpp
 */
#include <boost/assign.hpp>
#include <boost/range/adaptor/indexed.hpp>
 
#include <daq/fits/json.hpp>
#include <fmt/format.h>
#include <nlohmann/json.hpp>
 
#include <iostream>
namespace daq::fits {
 
namespace {
/**
 * 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(nlohmann::json const& obj) {
    assert(obj.is_object());
 
    if (!obj.contains("name")) {
        throw std::invalid_argument("field 'name' missing");
    }
    if (!obj["name"].is_string()) {
        throw std::invalid_argument("field 'name' must be a string");
    }
    if (!obj.contains("value")) {
        throw std::invalid_argument("field 'value' missing");
    }
 
    typename KeywordType::ValueType kw_value;
    auto name = obj["name"].get<std::string>();
    auto 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 std::invalid_argument(fmt::format(
                "field 'comment' type must be a string, got '{}'", comment.type_name()));
        }
        kw_comment = comment.get<std::string>();
    }
    return KeywordType(name, kw_value, kw_comment);
}
 
}  // namespace
 
std::vector<KeywordVariant> ParseJsonKeywords(char const* keywords) {
    // outer value must be an array
    auto parsed = nlohmann::json::parse(keywords);
    return ParseJsonKeywords(parsed);
}
 
std::vector<KeywordVariant> ParseJsonKeywords(nlohmann::json const& keywords) {
    using namespace boost::assign;
    using namespace boost::adaptors;
 
    if (!keywords.is_array()) {
        throw std::invalid_argument(
            fmt::format("root element parsing error: expected array of objects but got '{}'",
                        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();
 
        if (!kw_obj.is_object()) {
            throw std::invalid_argument(
                fmt::format("keyword [{}]: parsing error, expected array but got {}",
                            index.index(),
                            keywords.type_name()));
        }
        if (!kw_obj.contains("type")) {
            throw std::invalid_argument(
                fmt::format("keyword [{}]: parsing error: Field 'type' "
                            "missing",
                            index.index()));
        }
        if (!kw_obj["type"].is_string()) {
            throw std::invalid_argument(
                fmt::format("keyword [{}]: parsing error: Field 'type' "
                            "must be string",
                            index.index()));
        }
        try {
            auto type = kw_obj["type"].get<std::string>();
            if (type == "valueKeyword") {
                parsed_keywords.push_back(ParseKeywordObject<ValueKeyword>(kw_obj));
                // @todo validate parsed values (e.g. keyword length et.c.)?
            } else if (type == "esoKeyword") {
                parsed_keywords.push_back(ParseKeywordObject<EsoKeyword>(kw_obj));
                // @todo validate parsed values (e.g. keyword length et.c.)?
            } else {
                throw std::invalid_argument(
                    fmt::format("unknown keyword type, expected"
                                "one of 'valueKeyword' or 'esoKeyword', but got "
                                "{}",
                                type));
            }
        } catch (std::invalid_argument const& exc) {
            throw std::invalid_argument(
                fmt::format("keyword [{}]: parsing error: {}", index.index(), exc.what()));
        }
    }
 
    return parsed_keywords;
}
 
}  // namespace daq::fits