json_serializer.h

Go to the documentation of this file.

#pragma once
 
#include "di/container/action/sequence.h"
#include "di/container/interface/access.h"
#include "di/container/string/fixed_string_to_utf8_string_view.h"
#include "di/container/string/string_impl.h"
#include "di/container/string/string_view.h"
#include "di/container/string/utf8_encoding.h"
#include "di/container/vector/static_vector.h"
#include "di/function/invoke.h"
#include "di/io/interface/writer.h"
#include "di/io/prelude.h"
#include "di/io/string_writer.h"
#include "di/io/write_exactly.h"
#include "di/meta/core.h"
#include "di/meta/language.h"
#include "di/meta/operations.h"
#include "di/meta/util.h"
#include "di/reflect/enum_to_string.h"
#include "di/reflect/enumerator.h"
#include "di/reflect/field.h"
#include "di/reflect/reflect.h"
#include "di/reflect/type_name.h"
#include "di/serialization/serialize.h"
#include "di/serialization/serialize_string.h"
#include "di/util/declval.h"
#include "di/util/exchange.h"
#include "di/util/reference_wrapper.h"
#include "di/util/scope_value_change.h"
#include "di/vocab/error/result.h"
#include "di/vocab/tuple/tuple.h"
#include "di/vocab/tuple/tuple_element.h"
#include "di/vocab/tuple/tuple_for_each.h"
#include "di/vocab/tuple/tuple_sequence.h"
#include "di/vocab/variant/variant_types.h"
#include "di/vocab/variant/visit.h"
 
namespace di::serialization {
struct JsonFormat;
 
namespace detail {
    template<typename S, typename T>
    struct AllSerializable {
        constexpr static auto value = false;
    };
 
    template<typename S, typename... Types>
    struct AllSerializable<S, meta::List<Types...>> {
        constexpr static auto value = (concepts::Serializable<Types, S> && ...);
    };
 
    template<typename S, concepts::TypeList T>
    constexpr static auto all_serializable = AllSerializable<S, T>::value;
}
 
class JsonSerializerConfig {
public:
    JsonSerializerConfig() = default;
 
    constexpr auto pretty() const -> JsonSerializerConfig {
        auto config = *this;
        config.m_pretty = true;
        return config;
    }
 
    constexpr auto indent_width(int width) const -> JsonSerializerConfig {
        auto config = *this;
        config.m_indent_width = width;
        return config;
    }
 
    constexpr auto is_pretty() const -> bool { return m_pretty; }
    constexpr auto indent_width() const -> int { return m_indent_width; }
 
private:
    bool m_pretty { false };
    int m_indent_width { 4 };
};
 
template<concepts::Impl<Writer> Writer>
class JsonSerializer {
private:
    enum class State {
        First,
        Value,
        Normal,
    };
 
    class ObjectSerializerProxy {
    public:
        constexpr explicit ObjectSerializerProxy(JsonSerializer& serializer) : m_serializer(serializer) {}
 
        constexpr auto serialize_bool(container::StringView key, bool value) -> meta::WriterResult<void, Writer> {
            DI_TRY(m_serializer.get().serialize_key(key));
            auto guard = util::ScopeValueChange(m_serializer.get().m_state, State::Value);
            return m_serializer.get().serialize_bool(value);
        }
 
        constexpr auto serialize_null(container::StringView key) -> meta::WriterResult<void, Writer> {
            DI_TRY(m_serializer.get().serialize_key(key));
            auto guard = util::ScopeValueChange(m_serializer.get().m_state, State::Value);
            return m_serializer.get().serialize_null();
        }
 
        constexpr auto serialize_string(container::StringView key, container::StringView view)
            -> meta::WriterResult<void, Writer> {
            DI_TRY(m_serializer.get().serialize_key(key));
            auto guard = util::ScopeValueChange(m_serializer.get().m_state, State::Value);
            return m_serializer.get().serialize_string(view);
        }
 
        constexpr auto serialize_number(container::StringView key, concepts::Integral auto number)
            -> meta::WriterResult<void, Writer> {
            DI_TRY(m_serializer.get().serialize_key(key));
            auto guard = util::ScopeValueChange(m_serializer.get().m_state, State::Value);
            return m_serializer.get().serialize_number(number);
        }
 
        template<concepts::InvocableTo<meta::WriterResult<void, Writer>, JsonSerializer&> F>
        constexpr auto serialize_array(container::StringView key, F&& function) -> meta::WriterResult<void, Writer> {
            DI_TRY(m_serializer.get().serialize_key(key));
            auto guard = util::ScopeValueChange(m_serializer.get().m_state, State::Value);
            return m_serializer.get().serialize_array(util::forward<F>(function));
        }
 
        template<concepts::InvocableTo<meta::WriterResult<void, Writer>, ObjectSerializerProxy&> F>
        constexpr auto serialize_object(container::StringView key, F&& function) -> meta::WriterResult<void, Writer> {
            DI_TRY(m_serializer.get().serialize_key(key));
            auto guard = util::ScopeValueChange(m_serializer.get().m_state, State::Value);
            return m_serializer.get().serialize_object(util::forward<F>(function));
        }
 
        template<concepts::Serializable<JsonSerializer> T>
        constexpr auto serialize(container::StringView key, T&& value) -> meta::WriterResult<void, Writer> {
            DI_TRY(m_serializer.get().serialize_key(key));
            auto guard = util::ScopeValueChange(m_serializer.get().m_state, State::Value);
            return serialization::serialize(m_serializer.get(), value);
        }
 
    private:
        util::ReferenceWrapper<JsonSerializer> m_serializer;
    };
 
    constexpr static auto to_hex_digit(u8 value) -> c8 {
        DI_ASSERT(value < 16);
        if (value < 10) {
            return value + c8('0');
        }
        return (value - 10) + c8('A');
    }
 
public:
    using SerializationFormat = JsonFormat;
 
    template<typename T>
    requires(concepts::ConstructibleFrom<Writer, T>)
    constexpr explicit JsonSerializer(T&& writer, JsonSerializerConfig config = {})
        : m_writer(util::forward<T>(writer)), m_config(config) {}
 
    constexpr auto serialize_null() -> meta::WriterResult<void, Writer> {
        DI_TRY(serialize_comma());
 
        DI_TRY(io::write_exactly(m_writer, "null"_sv));
        return {};
    }
 
    constexpr auto serialize_bool(bool value) -> meta::WriterResult<void, Writer> {
        if (value) {
            return serialize_true();
        }
        return serialize_false();
    }
 
    constexpr auto serialize_string(container::StringView view) -> meta::WriterResult<void, Writer> {
        DI_TRY(serialize_comma());
 
        DI_TRY(io::write_exactly(m_writer, '"'));
        for (auto code_point_view : slide(view, 1)) {
            auto code_point = *front(code_point_view);
            // Check if we need to escape the code point
            if (code_point == U'"' || code_point == U'\\' || code_point <= 0x1Fu) {
                switch (code_point) {
                    case U'"':
                        DI_TRY(io::write_exactly(m_writer, "\\\""_sv));
                        continue;
                    case U'\\':
                        DI_TRY(io::write_exactly(m_writer, "\\\\"_sv));
                        continue;
                    case U'\b':
                        DI_TRY(io::write_exactly(m_writer, "\\b"_sv));
                        continue;
                    case U'\f':
                        DI_TRY(io::write_exactly(m_writer, "\\f"_sv));
                        continue;
                    case U'\n':
                        DI_TRY(io::write_exactly(m_writer, "\\n"_sv));
                        continue;
                    case U'\r':
                        DI_TRY(io::write_exactly(m_writer, "\\r"_sv));
                        continue;
                    case U'\t':
                        DI_TRY(io::write_exactly(m_writer, "\\t"_sv));
                        continue;
                    default:
                        auto text = di::Array { c8('\\'), c8('u'), c8('0'), c8('0'), c8('0'), c8('0') };
                        text[4] = to_hex_digit((code_point >> 4) & 0xF);
                        text[5] = to_hex_digit(code_point & 0xF);
                        DI_TRY(io::write_exactly(m_writer, StringView(encoding::assume_valid, text)));
                        continue;
                }
            }
            DI_TRY(io::write_exactly(m_writer, code_point_view));
        }
        DI_TRY(io::write_exactly(m_writer, '"'));
        return {};
    }
 
    constexpr auto serialize_number(concepts::Integral auto number) -> meta::WriterResult<void, Writer> {
        DI_TRY(serialize_comma());
 
        using Enc = container::string::Utf8Encoding;
        using TargetContext = format::BoundedFormatContext<Enc, meta::Constexpr<256ZU>>;
        auto context = TargetContext {};
        DI_TRY(di::format::vpresent_encoded_context<Enc>(
            di::container::string::StringViewImpl<Enc>(encoding::assume_valid, u8"{}", 2),
            di::format::make_format_args<TargetContext>(number), context));
 
        DI_TRY(io::write_exactly(m_writer, context.output()));
        return {};
    }
 
    template<concepts::InvocableTo<meta::WriterResult<void, Writer>, JsonSerializer&> F>
    constexpr auto serialize_array(F&& function) -> meta::WriterResult<void, Writer> {
        DI_TRY(serialize_array_begin());
        auto guard = util::ScopeValueChange(m_state, State::First);
        DI_TRY(function::invoke(util::forward<F>(function), *this));
        return serialize_array_end();
    }
 
    template<concepts::InvocableTo<meta::WriterResult<void, Writer>, ObjectSerializerProxy&> F>
    constexpr auto serialize_object(F&& function) -> meta::WriterResult<void, Writer> {
        DI_TRY(serialize_object_begin());
        auto guard = util::ScopeValueChange(m_state, State::First);
        auto proxy = ObjectSerializerProxy(*this);
        DI_TRY(function::invoke(util::forward<F>(function), proxy));
        return serialize_object_end();
    }
 
    template<typename T, concepts::InstanceOf<reflection::Fields> M>
    constexpr auto serialize(T&& value, M) -> meta::WriterResult<void, Writer> {
        return serialize_object([&](auto& serializer) -> meta::WriterResult<void, Writer> {
            return vocab::tuple_sequence<meta::WriterResult<void, Writer>>(
                [&](auto field) -> meta::WriterResult<void, Writer> {
                    constexpr auto name = container::fixed_string_to_utf8_string_view<field.name>();
 
                    using Type = meta::Type<decltype(field)>;
                    if constexpr (concepts::Optional<Type>) {
                        if (!field.get(value).has_value()) {
                            return {};
                        }
                        return serializer.serialize(name, *field.get(value));
                    } else {
                        return serializer.serialize(name, field.get(value));
                    }
                },
                M {});
        });
    }
 
    template<typename T, concepts::InstanceOf<reflection::Enumerators> M>
    constexpr auto serialize(T value, M) -> meta::WriterResult<void, Writer> {
        return serialize_string(reflection::enum_to_string(value));
    }
 
    template<typename T, concepts::InstanceOf<reflection::Atom> M>
    requires(M::is_bool() || M::is_string() || M::is_integer())
    constexpr auto serialize(T&& value, M) -> meta::WriterResult<void, Writer> {
        if constexpr (M::is_bool()) {
            return serialize_bool(M::get(value));
        } else if constexpr (M::is_string()) {
            return serialize_string(M::get(value));
        } else if constexpr (M::is_integer()) {
            return serialize_number(M::get(value));
        }
    }
 
    template<typename T, concepts::InstanceOf<reflection::Atom> M>
    constexpr auto serialize(T&& value, M) -> meta::WriterResult<void, Writer>
    requires(M::is_custom_atom() && requires { di::to_string(value); })
    {
        auto string = di::to_string(value);
        return serialize_string(string.view());
    }
 
    template<typename T, concepts::InstanceOf<reflection::Atom> M>
    requires(M::is_tuple() && detail::all_serializable<JsonSerializer, meta::TupleElements<T>>)
    constexpr auto serialize(T&& value, M) -> meta::WriterResult<void, Writer> {
        return serialize_array([&](auto& serializer) {
            return di::tuple_sequence<meta::WriterResult<void, Writer>>(
                [&](auto&& element) -> meta::WriterResult<void, Writer> {
                    return serialization::serialize(serializer, element);
                },
                M::get(value));
        });
    }
 
    template<typename T, concepts::InstanceOf<reflection::Atom> M>
    requires(M::is_variant() && detail::all_serializable<JsonSerializer, meta::VariantTypes<T>>)
    constexpr auto serialize(T&& value, M) -> meta::WriterResult<void, Writer> {
        return serialize_object([&](auto& serializer) {
            return di::visit(
                [&]<typename U>(U&& element) -> meta::WriterResult<void, Writer> {
                    constexpr auto name = container::fixed_string_to_utf8_string_view<di::type_name<U>>();
                    return serializer.serialize(name, element);
                },
                M::get(value));
        });
    }
 
    template<typename T, concepts::InstanceOf<reflection::Atom> M>
    requires(M::is_box() && concepts::Serializable<meta::Type<meta::RemoveCVRef<T>>, JsonSerializer>)
    constexpr auto serialize(T&& value, M) -> meta::WriterResult<void, Writer> {
        if (!value) {
            return serialize_null();
        }
        return serialization::serialize(*this, *value);
    }
 
    template<typename T, concepts::InstanceOf<reflection::Atom> M>
    requires(M::is_list() && concepts::Serializable<meta::ContainerReference<T>, JsonSerializer>)
    constexpr auto serialize(T&& value, M) -> meta::WriterResult<void, Writer> {
        return serialize_array([&](auto& serializer) {
            return container::sequence(M::get(value), [&](auto&& element) {
                return serialization::serialize(serializer, element);
            });
        });
    }
 
    template<typename T, concepts::InstanceOf<reflection::Atom> M>
    requires(M::is_map() && concepts::detail::ConstantString<meta::TupleElement<meta::ContainerValue<T>, 0>> &&
             concepts::Serializable<meta::TupleValue<decltype(util::declval<meta::ContainerReference<T>>()), 1>,
                                    JsonSerializer>)
    constexpr auto serialize(T&& value, M) -> meta::WriterResult<void, Writer> {
        return serialize_object([&](auto& serializer) {
            return container::sequence(M::get(value), [&](concepts::TupleLike auto&& element) {
                return serializer.serialize(util::get<0>(element), util::get<1>(element));
            });
        });
    }
 
    constexpr auto writer() & -> Writer& { return m_writer; }
    constexpr auto writer() const& -> Writer const& { return m_writer; }
    constexpr auto writer() && -> Writer&& { return util::move(*this).m_writer; }
 
private:
    constexpr auto serialize_true() -> meta::WriterResult<void, Writer> {
        DI_TRY(serialize_comma());
 
        DI_TRY(io::write_exactly(m_writer, "true"_sv));
        return {};
    }
 
    constexpr auto serialize_false() -> meta::WriterResult<void, Writer> {
        DI_TRY(serialize_comma());
 
        DI_TRY(io::write_exactly(m_writer, "false"_sv));
        return {};
    }
 
    constexpr auto serialize_comma() -> meta::WriterResult<void, Writer> {
        if (m_state == State::Value) {
            return {};
        }
        if (util::exchange(m_state, State::Normal) == State::Normal) {
            DI_TRY(io::write_exactly(m_writer, ','));
            DI_TRY(serialize_newline());
            DI_TRY(serialize_indent());
        } else if (m_indent > 0) {
            DI_TRY(serialize_newline());
            DI_TRY(serialize_indent());
        }
        return {};
    }
 
    constexpr auto serialize_object_begin() -> meta::WriterResult<void, Writer> {
        DI_TRY(serialize_comma());
        DI_TRY(io::write_exactly(m_writer, '{'));
        ++m_indent;
        return {};
    }
 
    constexpr auto serialize_object_end() -> meta::WriterResult<void, Writer> {
        --m_indent;
        if (m_state != State::First) {
            DI_TRY(serialize_newline());
            DI_TRY(serialize_indent());
        }
        DI_TRY(io::write_exactly(m_writer, '}'));
        return {};
    }
 
    constexpr auto serialize_array_begin() -> meta::WriterResult<void, Writer> {
        DI_TRY(serialize_comma());
        DI_TRY(io::write_exactly(m_writer, '['));
        ++m_indent;
        return {};
    }
 
    constexpr auto serialize_array_end() -> meta::WriterResult<void, Writer> {
        --m_indent;
        if (m_state != State::First) {
            DI_TRY(serialize_newline());
            DI_TRY(serialize_indent());
        }
        DI_TRY(io::write_exactly(m_writer, ']'));
        return {};
    }
 
    constexpr auto serialize_key(container::StringView key) -> meta::WriterResult<void, Writer> {
        DI_TRY(serialize_string(key));
        DI_TRY(io::write_exactly(m_writer, ':'));
        if (pretty_print()) {
            DI_TRY(io::write_exactly(m_writer, ' '));
        }
        return {};
    }
 
    constexpr auto serialize_newline() -> meta::WriterResult<void, Writer> {
        if (!pretty_print()) {
            return {};
        }
        return io::write_exactly(m_writer, '\n');
    }
 
    constexpr auto serialize_indent() -> meta::WriterResult<void, Writer> {
        if (!pretty_print()) {
            return {};
        }
        return view::range(m_indent * m_config.indent_width()) | container::sequence([&](auto) {
                   return io::write_exactly(m_writer, ' ');
               });
    }
 
    constexpr auto pretty_print() const -> bool { return m_config.is_pretty(); }
 
    Writer m_writer;
    JsonSerializerConfig m_config;
    usize m_indent { 0 };
    State m_state { State::First };
};
 
template<typename T>
JsonSerializer(T&&) -> JsonSerializer<T>;
 
template<typename T>
JsonSerializer(T&&, JsonSerializerConfig) -> JsonSerializer<T>;
 
template<concepts::Impl<io::Reader> Reader>
class JsonDeserializer;
 
struct JsonFormat {
    template<concepts::Impl<io::Writer> Writer, typename... Args>
    requires(concepts::ConstructibleFrom<JsonSerializer<meta::RemoveCVRef<Writer>>, Writer, Args...>)
    constexpr static auto serializer(Writer&& writer, Args&&... args) {
        return JsonSerializer<meta::RemoveCVRef<Writer>>(util::forward<Writer>(writer), util::forward<Args>(args)...);
    }
 
    template<concepts::Impl<io::Reader> Reader, typename... Args>
    requires(concepts::ConstructibleFrom<JsonDeserializer<meta::RemoveCVRef<Reader>>, Reader, Args...>)
    constexpr static auto deserializer(Reader&& reader, Args&&... args) {
        return JsonDeserializer<meta::RemoveCVRef<Reader>>(util::forward<Reader>(reader), util::forward<Args>(args)...);
    }
};
 
constexpr inline auto json_format = JsonFormat {};
 
namespace detail {
    struct ToJsonStringFunction {
        template<concepts::Serializable<JsonSerializer<io::StringWriter<>>> T, typename... Args>
        requires(concepts::ConstructibleFrom<JsonSerializer<io::StringWriter<>>, io::StringWriter<>, Args...>)
        constexpr auto operator()(T&& value, Args&&... args) const {
            return serialization::serialize_string(json_format, value, util::forward<Args>(args)...);
        }
    };
}
 
constexpr inline auto to_json_string = detail::ToJsonStringFunction {};
 
namespace detail {
    struct SerializeJsonFunction {
        template<concepts::Impl<io::Writer> Writer, concepts::Serializable<JsonSerializer<Writer>> T, typename... Args>
        requires(concepts::ConstructibleFrom<JsonSerializer<util::ReferenceWrapper<meta::RemoveReference<Writer>>>,
                                             util::ReferenceWrapper<meta::RemoveReference<Writer>>, Args...>)
        constexpr auto operator()(Writer&& writer, T&& value, Args&&... args) const {
            return serialize(json_format, util::ref(writer), value, util::forward<Args>(args)...);
        }
    };
}
 
constexpr inline auto serialize_json = detail::SerializeJsonFunction {};
}
 
namespace di {
using serialization::JsonFormat;
using serialization::JsonSerializer;
using serialization::JsonSerializerConfig;
 
using serialization::json_format;
using serialization::serialize_json;
using serialization::to_json_string;
}