internalParseUtils.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_libjson
 * @copyright
 * (c) Copyright ESO 2022
 * All Rights Reserved
 * ESO (eso.org) is an Intergovernmental Organisation, and therefore special legal conditions apply.
 */
#ifndef DAQ_INTERNAL_PARSE_UTILS_HPP
#define DAQ_INTERNAL_PARSE_UTILS_HPP
#include <string>
 
#include <fmt/format.h>
#include <nlohmann/json.hpp>
 
#include <daq/fits/json.hpp>
 
using Json = nlohmann::json;
using JsonPointer = nlohmann::json_pointer<Json>;
 
namespace daq {
 
template <class E, class... Args>
E MakeParseException(JsonPointer const& ptr, Args&&... args) {
    return E((fmt::format("({}) {}", ptr.to_string(), fmt::format(std::forward<Args>(args)...)))
                 .c_str());
}
 
template <class E, char const*>
E MakeParseException(JsonPointer const& ptr, char const* str) {
    return E(fmt::format("({}) {}", ptr.to_string(), str).c_str());
}
 
template <class E>
E MakeValueMissingException(JsonPointer const& ptr) {
    return E(fmt::format("({}) {}", ptr.to_string(), "mandatory value missing").c_str());
}
 
template <class E>
E MakeWrongTypeException(JsonPointer const& ptr,
                         char const* expected_type,
                         char const* actual_type) {
    return E(fmt::format("({}) {}",
                         ptr.to_string(),
                         fmt::format("must be a {}, but is {}", expected_type, actual_type))
                 .c_str());
}
 
template <class E>
E MakeUnknownVariantException(JsonPointer const& ptr,
                              char const* known_variants,
                              char const* actual_variant) {
    return E(
        fmt::format("({}) {}",
                    ptr.to_string(),
                    fmt::format("must be one of {}, but is '{}'", known_variants, actual_variant))
            .c_str());
}
 
template <class E>
std::pair<Json const&, JsonPointer>
GetMember(Json const& json, char const* name, JsonPointer const& breadcrumb) {
    auto bc = breadcrumb / name;
    if (!json.contains(name)) {
        throw MakeValueMissingException<E>(bc);
    }
    return {json[name], bc};
}
 
template <class E, class BinaryFunction>
std::pair<Json const&, JsonPointer> GetMember(Json const& json,
                                              char const* name,
                                              JsonPointer const& breadcrumb,
                                              BinaryFunction const& f) {
    auto res = GetMember<E>(json, name, breadcrumb);
    f(res.first, res.second);
    return res;
}
 
template <class E, class T>
struct JsonObject {
    static T
    Get(Json const& json, char const* name, JsonPointer const& breadcrumb, bool allow_empty = true);
};
 
template <class E>
struct JsonObject<E, std::string> {
    static std::string Get(Json const& json,
                           char const* name,
                           JsonPointer const& breadcrumb,
                           bool allow_empty = true) {
        if (!json.contains(name)) {
            throw MakeValueMissingException<E>(breadcrumb / name);
        }
        auto const& value_json = json[name];
        if (!value_json.is_string()) {
            throw MakeWrongTypeException<E>(breadcrumb / name, "string", value_json.type_name());
        }
        auto value = value_json.get<std::string>();
        if (value.empty() && !allow_empty) {
            throw MakeParseException<E>(breadcrumb / name, "empty string is invalid");
        }
        return value;
    }
};
 
template <class E>
struct JsonObject<E, double> {
    static double Get(Json const& json,
                      char const* name,
                      JsonPointer const& breadcrumb) {
        if (!json.contains(name)) {
            throw MakeValueMissingException<E>(breadcrumb / name);
        }
        auto const& value_json = json[name];
        if (!value_json.is_number()) {
            throw MakeWrongTypeException<E>(
                breadcrumb / name, "int or float", value_json.type_name());
        }
        auto value = value_json.get<double>();
        return value;
    }
};
 
template <class E>
struct JsonObject<E, bool> {
    static double Get(Json const& json,
                      char const* name,
                      JsonPointer const& breadcrumb) {
        if (!json.contains(name)) {
            throw MakeValueMissingException<E>(breadcrumb / name);
        }
        auto const& value_json = json[name];
        if (!value_json.is_boolean()) {
            throw MakeWrongTypeException<E>(
                breadcrumb / name, "boolean", value_json.type_name());
        }
        auto value = value_json.get<bool>();
        return value;
    }
};
 
template <class E>
void AssertIsObject(Json const& json, JsonPointer const& breadcrumb) {
    if (!json.is_object()) {
        throw MakeWrongTypeException<E>(breadcrumb, "object", json.type_name());
    }
}
 
template <class E>
void AssertIsArray(Json const& json, JsonPointer const& breadcrumb) {
    if (!json.is_array()) {
        throw MakeWrongTypeException<E>(breadcrumb, "array", json.type_name());
    }
}
 
template <class E>
std::vector<std::string> ParseArrayOfString(Json const& json, JsonPointer const& breadcrumb) {
    AssertIsArray<E>(json, breadcrumb);
    std::vector<std::string> result;
    auto index = 0u;
    for (auto const& value_json : json) {
        if (!value_json.is_string()) {
            throw MakeWrongTypeException<E>(breadcrumb / index, "string", value_json.type_name());
        }
        auto value = value_json.get<std::string>();
        if (value.empty()) {
            throw MakeParseException<E>(breadcrumb / index, "empty string is invalid");
        }
        result.emplace_back(std::move(value));
        index++;
    }
    return result;
}
}  // namespace daq
#endif  // DAQ_INTERNAL_PARSE_UTILS_HPP