serialization_base.h

/*********************************************************************************************************************************************/
/*  DocWire SDK: Award-winning modern data processing in C++20. SourceForge Community Choice & Microsoft support. AI-driven processing.      */
/*  Supports nearly 100 data formats, including email boxes and OCR. Boost efficiency in text extraction, web data extraction, data mining,  */
/*  document analysis. Offline processing possible for security and confidentiality                                                          */
/*                                                                                                                                           */
/*  Copyright (c) SILVERCODERS Ltd, http://silvercoders.com                                                                                  */
/*  Project homepage: https://github.com/docwire/docwire                                                                                     */
/*                                                                                                                                           */
/*  SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-DocWire-Commercial                                                                  */
/*********************************************************************************************************************************************/
 
#ifndef DOCWIRE_SERIALIZATION_BASE_H
#define DOCWIRE_SERIALIZATION_BASE_H
 
#include "concepts_container.h"
#include "concepts_misc.h"
#include "concepts_string.h"
#include "concepts_variant.h"
#include <cstdint>
#include <map>
#include <string>
#include <type_traits>
#include <variant>
#include <vector>
#include "type_name.h"
 
namespace docwire
{
 
namespace serialization
{
 
// Forward declarations for recursive variant types within the namespace
struct object;
struct array;
 
using value = std::variant<
    std::nullptr_t,
    bool,
    std::int64_t,
    std::uint64_t,
    double,
    std::string,
    array,
    object
>;
 
struct array { std::vector<value> v; };
 
struct object { std::map<std::string, value> v; };
 
enum class serializer_kind
{
    value_alternative,
    arithmetic,
    string_like,
    container,
    dereferenceable
};
 
inline value decorate_with_typeid(const value& base_val, const std::string& typeid_str)
{
    return object{{
        {"typeid", typeid_str},
        {"value", base_val}
    }};
}
template <typename T> value full(const T& value);
 
template <typename T>
struct serializer;
 
template <typename T>
value full(const T& value) { return serializer<T>{}.full(value); }
 
template <typename T>
value typed_summary(const T& value)
{
    return serializer<T>{}.typed_summary(value);
}
 
template <typename T>
concept value_alternative = variant_alternative<T, value>;
 
template <value_alternative T>
struct serializer<T>
{
    static constexpr serializer_kind kind = serializer_kind::value_alternative;
    value full(const T& value) const { return value; }
 
    value typed_summary(const T& value) const {
        return decorate_with_typeid(this->full(value), type_name::pretty<T>());
    }
};
 
template <typename T> requires(std::is_arithmetic_v<T> && !value_alternative<T>)
struct serializer<T>
{
    static constexpr serializer_kind kind = serializer_kind::arithmetic;
    value full(const T& value) const
    {
        if constexpr (std::is_integral_v<T> && std::is_signed_v<T>)
            return static_cast<std::int64_t>(value);
        else if constexpr (std::is_integral_v<T> && std::is_unsigned_v<T>)
            return static_cast<std::uint64_t>(value);
        else // is_floating_point
            return static_cast<double>(value);
    }
 
    value typed_summary(const T& value) const {
        return decorate_with_typeid(this->full(value), type_name::pretty<T>());
    }
};
 
template <typename T> requires string_like<T> && (!value_alternative<T>)
struct serializer<T>
{
    static constexpr serializer_kind kind = serializer_kind::string_like;
    value full(const T& val) const
    {
        if constexpr (std::is_pointer_v<std::decay_t<T>>) {
            if (val == nullptr) {
                return nullptr;
            }
        }
        return std::string(val);
    }
    value typed_summary(const T& val) const { return decorate_with_typeid(this->full(val), type_name::pretty<T>()); }
};
 
template <strong_type_alias T>
struct serializer<T>
{
    value full(const T& value) const { return serialization::full(value.v); }
    value typed_summary(const T& value) const { return decorate_with_typeid(full(value), type_name::pretty<T>()); }
};
 
template <empty T>
struct serializer<T>
{
    value full(const T& val) const { return object{}; }
    value typed_summary(const T& val) const { return decorate_with_typeid(this->full(val), type_name::pretty<T>()); }
};
 
template <typename T>
requires (dereferenceable<T> && !container<T> && !string_like<T> && !value_alternative<T>)
struct serializer<T>
{
    static constexpr serializer_kind kind = serializer_kind::dereferenceable;
 
    value full(const T& dereferenceable) const
    {
        if (dereferenceable) {
            return object{{{"value", serialization::full(*dereferenceable)}}};
        }
        return nullptr;
    }
 
    value typed_summary(const T& dereferenceable) const {
        if (dereferenceable) {
            return object{{
                {"typeid", type_name::pretty<T>()},
                {"value", serialization::typed_summary(*dereferenceable)}
            }};
        }
        return decorate_with_typeid(nullptr, type_name::pretty<T>());
    }
};
 
template <typename T> requires (container<T> && !string_like<T> && !value_alternative<T>)
struct serializer<T>
{
    static constexpr serializer_kind kind = serializer_kind::container;
    value full(const T& container) const
    {
        array arr;
        for (const auto& item : container) { arr.v.push_back(serialization::full(item)); }
        return arr;
    }
 
    value typed_summary(const T& container) const
    {
        array arr;
        for (const auto& item : container)
        {
            arr.v.push_back(serialization::typed_summary(item));
        }
        return decorate_with_typeid(arr, type_name::pretty<T>());
    }
};
 
template<typename... Ts>
struct serializer<std::variant<Ts...>>
{
    value full(const std::variant<Ts...>& variant) const
    {
        return std::visit([](const auto& value) {
            return object{{{"value", serialization::full(value)}}};
        }, variant);
    }
 
    value typed_summary(const std::variant<Ts...>& variant) const { return decorate_with_typeid(this->full(variant), type_name::pretty<std::variant<Ts...>>()); }
};
 
} // namespace serialization
 
} // namespace docwire
 
#endif // DOCWIRE_SERIALIZATION_BASE_H