json_serializer.h

Go to the documentation of this file.

/*
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Daniel Abele
*
* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MIO_IO_JSON_SERIALIZER_H
#define MIO_IO_JSON_SERIALIZER_H
 
#include "memilio/config.h" // IWYU pragma: keep
#include <boost/function_types/components.hpp>
#include <type_traits>
 
#ifdef MEMILIO_HAS_JSONCPP
 
#include "memilio/io/io.h"
#include "memilio/io/serializer_base.h"
#include "memilio/utils/metaprogramming.h"
 
#include "json/json.h" // IWYU pragma: keep
 
#include <fstream>
#include <limits>
#include <utility>
 
namespace mio
{
 
template <class T>
struct JsonType : std::false_type {
};
//bool
template <>
struct JsonType<bool> : std::true_type {
    static IOResult<bool> transform(const Json::Value& js)
    {
        if (js.isBool()) {
            return success(js.asBool());
        }
        return failure(StatusCode::InvalidType, "Json value is not a bool.");
    }
    static Json::Value transform(bool b)
    {
        return {b};
    }
};
// all integers less than 32 bit must be stored as int
 
//signed small ints
template <class T>
    requires(is_small_integral<T>::value && std::is_signed_v<T>)
struct JsonType<T> : std::true_type {
    static IOResult<T> transform(const Json::Value& js)
    {
        if (js.isInt()) {
            int i = js.asInt();
            if (i >= int(std::numeric_limits<T>::min()) && i <= int(std::numeric_limits<T>::max())) {
                return success(T(i));
            }
            return failure(StatusCode::OutOfRange, "Json value is not in range of the requested integer type.");
        }
        return failure(StatusCode::InvalidType, "Json value is not an integer.");
    }
    static Json::Value transform(T i)
    {
        return Json::Value(Json::Int(i));
    }
};
//unsigned small ints
template <class T>
    requires(is_small_integral<T>::value && std::is_unsigned_v<T>)
struct JsonType<T> : std::true_type {
    static IOResult<T> transform(const Json::Value& js)
    {
        if (js.isUInt()) {
            unsigned int i = js.asUInt();
            if (i <= (unsigned int)std::numeric_limits<T>::max()) {
                return success(T(i));
            }
            return failure(StatusCode::OutOfRange,
                           "Json value is not in range of the requested unsigned integer type.");
        }
        return failure(StatusCode::InvalidType, "Json value is not an unsigned integer.");
    }
    static Json::Value transform(T i)
    {
        return Json::Value(Json::UInt(i));
    }
};
//signed big ints
template <class T>
    requires(is_64bit_integral<T>::value && std::is_signed_v<T>)
struct JsonType<T> : std::true_type {
    static IOResult<T> transform(const Json::Value& js)
    {
        if (js.isInt64()) {
            return success(js.asInt64());
        }
        return failure(StatusCode::InvalidType, "Json value is not a 64 bit integer.");
    }
    static Json::Value transform(T i)
    {
        return {Json::Int64(i)};
    }
};
//unsigned big ints
template <class T>
    requires(is_64bit_integral<T>::value && std::is_unsigned_v<T>)
struct JsonType<T> : std::true_type {
    static IOResult<T> transform(const Json::Value& js)
    {
        if (js.isUInt64()) {
            return success(js.asUInt64());
        }
        return failure(StatusCode::InvalidType, "Json value is not an unsigned 64bit integer.");
    }
    static Json::Value transform(T i)
    {
        return {Json::UInt64(i)};
    }
};
//double
template <>
struct JsonType<double> : std::true_type {
 
    static IOResult<double> transform(const Json::Value& js)
    {
        if (js.isDouble()) {
            return success(js.asDouble());
        }
        return failure(StatusCode::InvalidType, "Json value is not a double.");
    }
    static Json::Value transform(double d)
    {
        return {d};
    }
};
//float
template <>
struct JsonType<float> : std::true_type {
    static IOResult<float> transform(const Json::Value& js)
    {
        if (js.isDouble()) {
            auto d = js.asDouble();
            if (d > double(std::numeric_limits<float>::max()) || d < -double(std::numeric_limits<float>::max())) {
                return failure(StatusCode::OutOfRange, "Json value is not in single precision floating point range.");
            }
            return success(float(d));
        }
        return failure(StatusCode::InvalidType, "Json value is not a float.");
    }
    static Json::Value transform(float f)
    {
        return {double(f)};
    }
};
//string
template <>
struct JsonType<std::string> : std::true_type {
    static IOResult<std::string> transform(const Json::Value& js)
    {
        if (js.isString()) {
            return success(js.asString());
        }
        return failure(StatusCode::InvalidType, "Json value is not a string.");
    }
    static Json::Value transform(const std::string& s)
    {
        return {s};
    }
};
//string literals
template <>
struct JsonType<const char*> : std::true_type {
    //cannot be read, but may be written (e.g. string literal), so only one way transform
    static Json::Value transform(const char* s)
    {
        return {s};
    }
};
template <class T>
concept IsJsonType = JsonType<T>::value;
 
class JsonObject : public SerializerBase
{
public:
    JsonObject(Json::Value& value, const std::shared_ptr<IOStatus>& status, int flags)
        : SerializerBase{status, flags}
        , m_value{value}
    {
    }
 
    template <class T>
        requires(IsJsonType<T>)
    void add_element(const std::string& name, const T& value);
    template <class T>
        requires(!IsJsonType<T>)
    void add_element(const std::string& name, const T& value);
    template <class T>
    void add_optional(const std::string& name, const T* value);
 
    template <class Iter>
    void add_list(const std::string& name, Iter b, Iter e);
 
    template <class T>
        requires(IsJsonType<T>)
    IOResult<T> expect_element(const std::string& name, Tag<T> tag) const;
    template <class T>
        requires(!IsJsonType<T>)
    IOResult<T> expect_element(const std::string& name, Tag<T> tag) const;
    template <class T>
    IOResult<boost::optional<T>> expect_optional(const std::string& name, mio::Tag<T> tag);
 
    template <class T>
    IOResult<std::vector<T>> expect_list(const std::string& name, Tag<T> tag);
 
    const auto& value() const&
    {
        return m_value;
    }
 
private:
    Json::Value& m_value;
};
 
class JsonContext : public SerializerBase
{
public:
    JsonContext(const std::shared_ptr<IOStatus>& status, int flags)
        : SerializerBase{status, flags}
        , m_value{}
    {
    }
 
    JsonContext(Json::Value value, const std::shared_ptr<IOStatus>& status, int flags)
        : SerializerBase(status, flags)
        , m_value(std::move(value))
    {
    }
 
    JsonObject create_object(const std::string& type)
    {
        mio::unused(type);
        m_value = Json::Value(Json::objectValue);
        return {m_value, m_status, m_flags};
    }
 
    JsonObject expect_object(const std::string& type)
    {
        mio::unused(type);
        if (!m_value.isObject()) {
            *m_status = IOStatus(StatusCode::InvalidType, "Json value must be an object.");
        }
        return {m_value, m_status, m_flags};
    }
 
    const Json::Value& value() const&
    {
        return m_value;
    }
    Json::Value&& value() &&
    {
        return std::move(m_value);
    }
    template <class T>
        requires(IsJsonType<T>)
    friend void serialize_internal(JsonContext& io, const T& t)
    {
        io.m_value = JsonType<T>::transform(t);
    }
 
    template <class T>
        requires(IsJsonType<T>)
    friend IOResult<T> deserialize_internal(JsonContext& io, Tag<T>)
    {
        return JsonType<T>::transform(io.m_value);
    }
 
    template <IsContainer Container>
        requires(!IsJsonType<Container> && !HasDeserialize<Container, JsonContext>)
    friend void serialize_internal(JsonContext& io, const Container& v)
    {
        if (io.m_status->is_ok()) {
            auto array = Json::Value(Json::arrayValue);
            using std::begin;
            using std::end;
            for (auto it = begin(v); it != end(v); ++it) {
                auto ctxt = JsonContext(io.m_status, io.m_flags);
                mio::serialize(ctxt, *it);
                if (io.m_status) {
                    array.append(std::move(ctxt).value());
                }
            }
            io.m_value = std::move(array);
        }
    }
 
    template <IsContainer Container>
        requires(!IsJsonType<Container> && !HasDeserialize<Container, JsonContext>)
    friend IOResult<Container> deserialize_internal(JsonContext& io, Tag<Container>)
    {
        const auto& array = io.m_value;
        if (array.isArray()) {
            Container v;
            for (auto&& el : array) {
                auto ctxt = JsonContext(el, io.m_status, io.m_flags);
                BOOST_OUTCOME_TRY(auto&& val, mio::deserialize(ctxt, Tag<typename Container::value_type>{}));
                v.insert(v.end(), val);
            }
            return success(std::move(v));
        }
        return failure(StatusCode::InvalidType, "Json value must be an array.");
    }
 
private:
    Json::Value m_value;
};
 
inline IOResult<void> write_json(const std::string& path, const Json::Value& js_value)
{
    std::ofstream ofs(path);
    if (ofs.is_open()) {
        Json::StreamWriterBuilder swb;
        auto js_writer = std::unique_ptr<Json::StreamWriter>(swb.newStreamWriter());
        js_writer->write(js_value, &ofs);
        if (ofs) {
            return success();
        }
        else {
            return failure(StatusCode::UnknownError, "Unknown error writing json.");
        }
    }
    else {
        return failure(StatusCode::FileNotFound, path);
    }
}
 
template <class T>
IOResult<Json::Value> serialize_json(const T& t, int flags = IOF_None)
{
    JsonContext ctxt{std::make_shared<IOStatus>(), flags};
    serialize(ctxt, t);
    if (!ctxt.status()) {
        return failure(ctxt.status());
    }
    return success(ctxt.value());
}
 
template <class T>
IOResult<void> write_json(const std::string& path, const T& t, int flags = IOF_None)
{
    BOOST_OUTCOME_TRY(auto&& js, serialize_json(t, flags));
    return write_json(path, js);
}
 
inline IOResult<Json::Value> read_json(const std::string& path)
{
    std::ifstream ifs(path);
    if (ifs.is_open()) {
        Json::CharReaderBuilder crb;
        std::string err_msg;
        Json::Value js_value;
        if (Json::parseFromStream(crb, ifs, &js_value, &err_msg)) {
            return success(js_value);
        }
        return failure(StatusCode::UnknownError, path + ", " + err_msg);
    }
    return failure(StatusCode::FileNotFound, path);
}
 
template <class T>
IOResult<T> deserialize_json(const Json::Value& js, Tag<T> tag, int flags = IOF_None)
{
    JsonContext ctxt{js, std::make_shared<IOStatus>(), flags};
    return deserialize(static_cast<JsonContext&>(ctxt), tag);
}
 
template <class T>
IOResult<T> read_json(const std::string& path, Tag<T> tag, int flags = IOF_None)
{
    BOOST_OUTCOME_TRY(auto&& js, read_json(path));
    return deserialize_json(js, tag, flags);
}
 
//Implementations for JsonContext/Object member functions below//
 
template <class T>
    requires(IsJsonType<T>)
void JsonObject::add_element(const std::string& name, const T& value)
{
    if (m_status->is_ok()) {
        m_value[name] = JsonType<T>::transform(value);
    }
}
 
template <class T>
    requires(!IsJsonType<T>)
void JsonObject::add_element(const std::string& name, const T& value)
{
    if (m_status->is_ok()) {
        auto ctxt = JsonContext(m_status, m_flags);
        mio::serialize(ctxt, value);
        if (m_status) {
            m_value[name] = std::move(ctxt).value();
        }
    }
}
 
template <class T>
void JsonObject::add_optional(const std::string& name, const T* value)
{
    if (value) {
        add_element(name, *value);
    }
}
 
template <class Iter>
void JsonObject::add_list(const std::string& name, Iter b, Iter e)
{
    if (m_status->is_ok()) {
        auto array = Json::Value(Json::arrayValue);
        for (auto it = b; it != e; ++it) {
            auto ctxt = JsonContext(m_status, m_flags);
            mio::serialize(ctxt, *it);
            if (m_status) {
                array.append(std::move(ctxt).value());
            }
        }
        m_value[name] = std::move(array);
    }
}
 
template <class T>
    requires(IsJsonType<T>)
IOResult<T> JsonObject::expect_element(const std::string& name, Tag<T> /*tag*/) const
{
    if (m_status->is_error()) {
        return failure(*m_status);
    }
 
    const auto& element = m_value[name];
    if (element.isNull()) {
        return failure(StatusCode::KeyNotFound, name);
    }
    auto r = JsonType<T>::transform(element);
    if (r) {
        return r;
    }
 
    return failure(r.error().code(),
                   r.error().message() + " (" + name + ")"); //annotate type error message with element name
}
 
template <class T>
    requires(!IsJsonType<T>)
IOResult<T> JsonObject::expect_element(const std::string& name, Tag<T> tag) const
{
    if (m_status->is_error()) {
        return failure(*m_status);
    }
    const auto& element = m_value[name];
    if (!element.isNull()) {
        auto ctxt = JsonContext(element, m_status, m_flags);
        auto r    = mio::deserialize(ctxt, tag);
        return r;
    }
    return failure(IOStatus{StatusCode::KeyNotFound, name});
}
 
template <class T>
IOResult<boost::optional<T>> JsonObject::expect_optional(const std::string& name, mio::Tag<T> tag)
{
    if (m_status->is_error()) {
        return failure(*m_status);
    }
    const auto& element = m_value[name];
    if (element.isNull()) {
        return success(boost::optional<T>{});
    }
    auto r = expect_element(name, tag);
    if (r) {
        return success(r.value());
    }
    return failure(r.error());
}
 
template <class T>
IOResult<std::vector<T>> JsonObject::expect_list(const std::string& name, Tag<T> tag)
{
    if (m_status->is_error()) {
        return failure(*m_status);
    }
    const auto& array = m_value[name];
    if (array.isArray()) {
        std::vector<T> v;
        v.reserve(array.size());
        for (auto&& el : array) {
            auto ctxt = JsonContext(el, m_status, m_flags);
            auto r    = mio::deserialize(ctxt, tag);
            if (r) {
                v.emplace_back(r.value());
            }
            else {
                return failure(r.error());
            }
        }
        return success(std::move(v));
    }
    return failure(StatusCode::KeyNotFound, name);
}
 
} // namespace mio
 
#endif // MEMILIO_HAS_JSONCPP
 
#endif // MIO_IO_JSON_SERIALIZER_H