json.hpp

#pragma once
 
#include "fly/concepts/concepts.hpp"
#include "fly/types/json/concepts.hpp"
#include "fly/types/json/detail/array_util.hpp"
#include "fly/types/json/detail/json_iterator.hpp"
#include "fly/types/json/detail/json_reverse_iterator.hpp"
#include "fly/types/json/json_exception.hpp"
#include "fly/types/json/types.hpp"
#include "fly/types/numeric/literals.hpp"
#include "fly/types/string/concepts.hpp"
#include "fly/types/string/string.hpp"
 
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <exception>
#include <functional>
#include <initializer_list>
#include <map>
#include <optional>
#include <string>
#include <type_traits>
#include <variant>
#include <vector>
 
// Helper macros to choose the correct string literal prefix to use for JSON string types.
#define FLY_JSON_CHR(ch) FLY_CHR(fly::json_char_type, ch)
#define FLY_JSON_STR(str) FLY_STR(fly::json_char_type, str)
#define FLY_JSON_ARR(arr) FLY_ARR(fly::json_char_type, arr)
 
namespace fly {
 
class Json
{
public:
    using value_type = Json;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using allocator_type = std::allocator<value_type>;
    using reference = value_type &;
    using const_reference = const value_type &;
    using pointer = typename std::allocator_traits<allocator_type>::pointer;
    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
    using iterator = detail::JsonIterator<Json>;
    using const_iterator = detail::JsonIterator<const Json>;
    using reverse_iterator = detail::JsonReverseIterator<iterator>;
    using const_reverse_iterator = detail::JsonReverseIterator<const_iterator>;
 
    Json() = default;
 
    Json(json_null_type value) noexcept;
 
    template <JsonStringLike T>
    Json(T value) noexcept(false);
 
    template <JsonObject T>
    Json(T value) noexcept(false);
 
    template <JsonArray T>
    Json(T value) noexcept(false);
 
    template <JsonBoolean T>
    Json(T value) noexcept;
 
    template <JsonSignedInteger T>
    Json(T value) noexcept;
 
    template <JsonUnsignedInteger T>
    Json(T value) noexcept;
 
    template <JsonFloatingPoint T>
    Json(T value) noexcept;
 
    Json(const_reference json) noexcept;
 
    Json(Json &&json) noexcept;
 
    Json(std::initializer_list<Json> initializer) noexcept;
 
    reference operator=(Json json) noexcept;
 
    json_string_type serialize() const;
 
    bool is_null() const;
 
    bool is_string() const;
 
    bool is_object() const;
 
    bool is_object_like() const;
 
    bool is_array() const;
 
    bool is_boolean() const;
 
    bool is_signed_integer() const;
 
    bool is_unsigned_integer() const;
 
    bool is_float() const;
 
    //==============================================================================================
    //
    // Conversion operators
    //
    //==============================================================================================
 
    explicit operator json_null_type() const noexcept(false);
 
    template <JsonString T>
    explicit operator T() const &noexcept(false);
 
    explicit operator json_string_type() &&noexcept(false);
 
    template <JsonObject T>
    explicit operator T() const &noexcept(false);
 
    explicit operator json_object_type() &&noexcept(false);
 
    template <JsonArray T>
    explicit operator T() const &noexcept(false);
 
    explicit operator json_array_type() &&noexcept(false);
 
    template <typename T, std::size_t N>
    explicit operator std::array<T, N>() const noexcept(false);
 
    template <JsonBoolean T>
    explicit operator T() const noexcept;
 
    template <JsonNumber T>
    explicit operator T() const noexcept(false);
 
    //==============================================================================================
    //
    // Element accessors
    //
    //==============================================================================================
 
    template <JsonStringLike T>
    reference at(T key);
 
    template <JsonStringLike T>
    const_reference at(T key) const;
 
    reference at(size_type index);
 
    const_reference at(size_type index) const;
 
    template <JsonStringLike T>
    reference operator[](T key);
 
    template <JsonStringLike T>
    const_reference operator[](T key) const;
 
    reference operator[](size_type index);
 
    const_reference operator[](size_type index) const;
 
    reference front();
 
    const_reference front() const;
 
    reference back();
 
    const_reference back() const;
 
    //==============================================================================================
    //
    // Iterators
    //
    //==============================================================================================
 
    iterator begin();
 
    const_iterator begin() const;
 
    const_iterator cbegin() const;
 
    iterator end();
 
    const_iterator end() const;
 
    const_iterator cend() const;
 
    reverse_iterator rbegin();
 
    const_reverse_iterator rbegin() const;
 
    const_reverse_iterator crbegin() const;
 
    reverse_iterator rend();
 
    const_reverse_iterator rend() const;
 
    const_reverse_iterator crend() const;
 
    //==============================================================================================
    //
    // Capacity
    //
    //==============================================================================================
 
    bool empty() const;
 
    size_type size() const;
 
    void resize(size_type size);
 
    size_type capacity() const;
 
    void reserve(size_type capacity);
 
    //==============================================================================================
    //
    // Modifiers
    //
    //==============================================================================================
 
    void clear();
 
    template <JsonStringLike Key>
    std::pair<iterator, bool> insert(Key key, const Json &value);
 
    template <JsonStringLike Key>
    std::pair<iterator, bool> insert(Key key, Json &&value);
 
    void insert(const_iterator first, const_iterator last);
 
    iterator insert(const_iterator position, const Json &value);
 
    iterator insert(const_iterator position, Json &&value);
 
    iterator insert(const_iterator position, size_type count, const Json &value);
 
    iterator insert(const_iterator position, const_iterator first, const_iterator last);
 
    iterator insert(const_iterator position, std::initializer_list<Json> initializer);
 
    template <JsonStringLike Key>
    std::pair<iterator, bool> insert_or_assign(Key key, Json &&value);
 
    template <JsonStringLike Key, typename Value>
    std::pair<iterator, bool> emplace(Key key, Value &&value);
 
    template <typename... Args>
    Json::reference emplace_back(Args &&...args);
 
    void push_back(const Json &value);
 
    void push_back(Json &&value);
 
    void pop_back();
 
    template <JsonStringLike T>
    size_type erase(T key);
 
    void erase(size_type index);
 
    iterator erase(const_iterator position);
 
    iterator erase(const_iterator first, const_iterator last);
 
    void swap(reference json);
 
    template <JsonString T>
    void swap(T &other);
 
    template <JsonObject T>
    void swap(T &other);
 
    template <JsonArray T>
    void swap(T &other);
 
    void merge(Json &other);
 
    void merge(Json &&other);
 
    template <JsonObject T>
    void merge(T &other);
 
    template <JsonObject T>
    void merge(T &&other);
 
    //==============================================================================================
    //
    // Lookup
    //
    //==============================================================================================
 
    template <JsonStringLike T>
    size_type count(T key) const;
 
    template <JsonStringLike T>
    iterator find(T key);
 
    template <JsonStringLike T>
    const_iterator find(T key) const;
 
    template <JsonStringLike T>
    bool contains(T key) const;
 
    //==============================================================================================
    //
    // Non-member functions
    //
    //==============================================================================================
 
    friend bool operator==(const_reference json1, const_reference json2);
 
    friend bool operator!=(const_reference json1, const_reference json2);
 
    friend bool operator<(const_reference json1, const_reference json2);
 
    friend bool operator<=(const_reference json1, const_reference json2);
 
    friend bool operator>(const_reference json1, const_reference json2);
 
    friend bool operator>=(const_reference json1, const_reference json2);
 
private:
    friend iterator;
    friend const_iterator;
    friend struct std::hash<Json>;
 
    template <JsonStringLike T>
    static json_string_type convert_to_string(T value);
 
    static json_string_type validate_string(json_string_type &&value);
 
    static void read_escaped_character(json_string_type &value, json_string_type::iterator &it);
 
    static void write_escaped_character(
        json_string_type &output,
        json_string_type::const_iterator &it,
        const json_string_type::const_iterator &end);
 
    template <typename... Args>
    using object_insertion_result = std::conditional_t<
        std::is_void_v<decltype(std::declval<json_object_type>().insert(std::declval<Args>()...))>,
        void,
        std::pair<iterator, bool>>;
 
    template <typename... Args>
    object_insertion_result<Args...> object_inserter(Args &&...args);
 
    template <typename... Args>
    iterator array_inserter(const_iterator position, Args &&...args);
 
    template <typename T>
    T &get(const char *error_message);
 
    template <typename T>
    T &get_or_promote(const char *error_message);
 
    template <typename T>
    const T &get(const char *error_message) const;
 
    json_type m_value {nullptr};
};
 
//==================================================================================================
template <JsonStringLike T>
Json::Json(T value) noexcept(false) : m_value(convert_to_string(std::move(value)))
{
}
 
//==================================================================================================
template <JsonObject T>
Json::Json(T value) noexcept(false) : m_value(json_object_type())
{
    for (auto &it : value)
    {
        insert(std::move(it.first), std::move(it.second));
    }
}
 
//==================================================================================================
template <JsonArray T>
Json::Json(T value) noexcept(false) : m_value(json_array_type())
{
    reserve(detail::json_array_size(value));
 
    for (auto &it : value)
    {
        push_back(std::move(it));
    }
}
 
//==================================================================================================
template <JsonBoolean T>
Json::Json(T value) noexcept : m_value(static_cast<json_boolean_type>(value))
{
}
 
//==================================================================================================
template <JsonSignedInteger T>
Json::Json(T value) noexcept : m_value(static_cast<json_signed_integer_type>(value))
{
}
 
//==================================================================================================
template <JsonUnsignedInteger T>
Json::Json(T value) noexcept : m_value(static_cast<json_unsigned_integer_type>(value))
{
}
 
//==================================================================================================
template <JsonFloatingPoint T>
Json::Json(T value) noexcept : m_value(static_cast<json_floating_point_type>(value))
{
}
 
//==================================================================================================
template <JsonString T>
Json::operator T() const &noexcept(false)
{
    auto visitor = [this](const auto &storage) -> T {
        using S = decltype(storage);
 
        if constexpr (JsonString<S>)
        {
            if constexpr (fly::SameAs<T, json_string_type>)
            {
                return storage;
            }
            else
            {
                // The JSON string will have been validated for Unicode compliance during
                // construction.
                return *(JsonStringType::convert<T>(storage));
            }
        }
        else if constexpr (JsonNumber<S>)
        {
            using char_type = typename T::value_type;
            return BasicString<char_type>::format(FLY_ARR(char_type, "{}"), storage);
        }
        else
        {
            throw JsonException(*this, "JSON type is not a string");
        }
    };
 
    return std::visit(std::move(visitor), m_value);
}
 
//==================================================================================================
template <JsonObject T>
Json::operator T() const &noexcept(false)
{
    const auto &storage = get<json_object_type>("JSON type is not an object");
    T result;
 
    for (const auto &it : storage)
    {
        // The JSON string will have been validated for Unicode compliance during construction.
        auto key = *std::move(JsonStringType::convert<typename T::key_type>(it.first));
        result.emplace(std::move(key), it.second);
    }
 
    return result;
}
 
//==================================================================================================
template <JsonArray T>
Json::operator T() const &noexcept(false)
{
    const auto &storage = get<json_array_type>("JSON type is not an array");
    T result {};
 
    for (const auto &it : storage)
    {
        auto copy = static_cast<typename T::value_type>(it);
        detail::json_array_append(result, std::move(copy));
    }
 
    return result;
}
 
//==================================================================================================
template <typename T, std::size_t N>
Json::operator std::array<T, N>() const noexcept(false)
{
    const auto &storage = get<json_array_type>("JSON type is not an array");
    std::array<T, N> result {};
 
    for (std::size_t i = 0; i < std::min(N, storage.size()); ++i)
    {
        result[i] = T(storage.at(i));
    }
 
    return result;
}
 
//==================================================================================================
template <JsonBoolean T>
Json::operator T() const noexcept
{
    auto visitor = [](const auto &storage) noexcept -> T {
        using S = decltype(storage);
 
        if constexpr (JsonContainer<S>)
        {
            return !storage.empty();
        }
        else if constexpr (JsonFloatingPoint<S>)
        {
            return std::abs(storage) > static_cast<S>(0);
        }
        else if constexpr (JsonNull<S>)
        {
            return false;
        }
        else
        {
            return storage != static_cast<S>(0);
        }
    };
 
    return std::visit(std::move(visitor), m_value);
}
 
//==================================================================================================
template <JsonNumber T>
Json::operator T() const noexcept(false)
{
    auto visitor = [this](const auto &storage) -> T {
        using S = decltype(storage);
 
        if constexpr (JsonString<S>)
        {
            if (auto converted = JsonStringType::convert<T>(storage); converted)
            {
                return *std::move(converted);
            }
        }
        else if constexpr (JsonNumber<S>)
        {
            return static_cast<T>(storage);
        }
 
        throw JsonException(*this, "JSON type is not numeric");
    };
 
    return std::visit(std::move(visitor), m_value);
}
 
//==================================================================================================
template <JsonStringLike T>
Json::reference Json::at(T key)
{
    auto &storage = get<json_object_type>("JSON type invalid for operator[key]");
    auto it = storage.find(convert_to_string(std::move(key)));
 
    if (it == storage.end())
    {
        throw JsonException(*this, String::format("Given key ({}) not found", key));
    }
 
    return it->second;
}
 
//==================================================================================================
template <JsonStringLike T>
Json::const_reference Json::at(T key) const
{
    const auto &storage = get<json_object_type>("JSON type invalid for operator[key]");
    const auto it = storage.find(convert_to_string(std::move(key)));
 
    if (it == storage.end())
    {
        throw JsonException(*this, String::format("Given key ({}) not found", key));
    }
 
    return it->second;
}
 
//==================================================================================================
template <JsonStringLike T>
Json::reference Json::operator[](T key)
{
    auto &storage = get_or_promote<json_object_type>("JSON type invalid for operator[key]");
    return storage[convert_to_string(std::move(key))];
}
 
//==================================================================================================
template <JsonStringLike T>
Json::const_reference Json::operator[](T key) const
{
    return at(key);
}
 
//==================================================================================================
template <JsonStringLike Key>
std::pair<Json::iterator, bool> Json::insert(Key key, const Json &value)
{
    return object_inserter(std::make_pair(convert_to_string(std::move(key)), value));
}
 
//==================================================================================================
template <JsonStringLike Key>
std::pair<Json::iterator, bool> Json::insert(Key key, Json &&value)
{
    return object_inserter(std::make_pair(convert_to_string(std::move(key)), std::move(value)));
}
 
//==================================================================================================
template <JsonStringLike Key>
std::pair<Json::iterator, bool> Json::insert_or_assign(Key key, Json &&value)
{
    auto result = insert(key, value);
 
    if (!result.second)
    {
        auto &it = std::get<typename iterator::object_iterator_type>(result.first.m_iterator);
        it->second.swap(value);
    }
 
    return result;
}
 
//==================================================================================================
template <JsonStringLike Key, typename Value>
std::pair<Json::iterator, bool> Json::emplace(Key key, Value &&value)
{
    auto &storage = get_or_promote<json_object_type>("JSON type invalid for object emplacement");
    auto result = storage.emplace(convert_to_string(std::move(key)), std::forward<Value>(value));
 
    auto it = end();
    it.m_iterator = result.first;
 
    return {it, result.second};
}
 
//==================================================================================================
template <typename... Args>
Json::reference Json::emplace_back(Args &&...args)
{
    auto &storage = get_or_promote<json_array_type>("JSON type invalid for array emplacement");
    return storage.emplace_back(std::forward<Args>(args)...);
}
 
//==================================================================================================
template <JsonStringLike T>
Json::size_type Json::erase(T key)
{
    auto &storage = get<json_object_type>("JSON type invalid for erase(key)");
    return storage.erase(convert_to_string(std::move(key)));
}
 
//==================================================================================================
template <JsonString T>
void Json::swap(T &other)
{
    if (!is_string())
    {
        throw JsonException(*this, "JSON type invalid for swap(string)");
    }
 
    T string = static_cast<T>(*this);
 
    *this = std::move(other);
    other = std::move(string);
}
 
//==================================================================================================
template <JsonObject T>
void Json::swap(T &other)
{
    if (!is_object())
    {
        throw JsonException(*this, "JSON type invalid for swap(object)");
    }
 
    T object = static_cast<T>(*this);
 
    *this = std::move(other);
    other = std::move(object);
}
 
//==================================================================================================
template <JsonArray T>
void Json::swap(T &other)
{
    if (!is_array())
    {
        throw JsonException(*this, "JSON type invalid for swap(array)");
    }
 
    T array = static_cast<T>(*this);
 
    *this = std::move(other);
    other = std::move(array);
}
 
//==================================================================================================
template <JsonObject T>
void Json::merge(T &other)
{
    get_or_promote<json_object_type>("JSON type invalid for merging");
 
    // Manual implementation of fly::json_object_type::merge(&) to allow unordered maps.
    for (auto it = other.begin(); it != other.end();)
    {
        if (contains(it->first))
        {
            ++it;
        }
        else
        {
            insert(std::move(it->first), std::move(it->second));
            it = other.erase(it);
        }
    }
}
 
//==================================================================================================
template <JsonObject T>
void Json::merge(T &&other)
{
    get_or_promote<json_object_type>("JSON type invalid for merging");
 
    // Manual implementation of fly::json_object_type::merge(&&) to allow unordered maps.
    for (auto &&it : other)
    {
        if (!contains(it.first))
        {
            insert(std::move(it.first), std::move(it.second));
        }
    }
}
 
//==================================================================================================
template <JsonStringLike T>
Json::size_type Json::count(T key) const
{
    const auto &storage = get<json_object_type>("JSON type invalid for count(key)");
    return storage.count(convert_to_string(std::move(key)));
}
 
//==================================================================================================
template <JsonStringLike T>
Json::iterator Json::find(T key)
{
    auto &storage = get<json_object_type>("JSON type invalid for find(key)");
 
    auto it = end();
    it.m_iterator = storage.find(convert_to_string(std::move(key)));
 
    return it;
}
 
//==================================================================================================
template <JsonStringLike T>
Json::const_iterator Json::find(T key) const
{
    const auto &storage = get<json_object_type>("JSON type invalid for find(key)");
 
    auto it = cend();
    it.m_iterator = storage.find(convert_to_string(std::move(key)));
 
    return it;
}
 
//==================================================================================================
template <JsonStringLike T>
bool Json::contains(T key) const
{
    const auto &storage = get<json_object_type>("JSON type invalid for contains(key)");
    return storage.contains(convert_to_string(std::move(key)));
}
 
//==================================================================================================
template <JsonStringLike T>
json_string_type Json::convert_to_string(T value)
{
    using StringType = BasicString<fly::StandardCharacterType<T>>;
 
    if constexpr (fly::SameAs<typename StringType::string_type, json_string_type>)
    {
        if (StringType::validate(value))
        {
            return validate_string(std::move(value));
        }
    }
    else
    {
        if (auto result = StringType::template convert<json_string_type>(value); result)
        {
            return validate_string(*std::move(result));
        }
    }
 
    throw JsonException("Could not convert string-like type to a JSON string");
}
 
//==================================================================================================
template <typename... Args>
Json::object_insertion_result<Args...> Json::object_inserter(Args &&...args)
{
    auto &storage = get<json_object_type>("JSON type invalid for object insertion");
 
    if constexpr (std::is_void_v<object_insertion_result<Args...>>)
    {
        storage.insert(std::forward<Args>(args)...);
    }
    else
    {
        auto result = storage.insert(std::forward<Args>(args)...);
 
        auto it = end();
        it.m_iterator = result.first;
 
        return {it, result.second};
    }
}
 
//==================================================================================================
template <typename... Args>
Json::iterator Json::array_inserter(const_iterator position, Args &&...args)
{
    auto &storage = get<json_array_type>("JSON type invalid for array insertion");
 
    if (position.m_json != this)
    {
        throw JsonException("Provided iterator is for a different Json instance");
    }
 
    const auto &position_iterator =
        std::get<typename const_iterator::array_iterator_type>(position.m_iterator);
 
    auto it = end();
    it.m_iterator = storage.insert(position_iterator, std::forward<Args>(args)...);
 
    return it;
}
 
//==================================================================================================
template <typename T>
inline T &Json::get(const char *error_message)
{
    auto *storage = std::get_if<T>(&m_value);
 
    if (storage == nullptr)
    {
        throw JsonException(*this, error_message);
    }
 
    return *storage;
}
 
//==================================================================================================
template <typename T>
inline T &Json::get_or_promote(const char *error_message)
{
    auto *storage = std::get_if<T>(&m_value);
 
    if (storage == nullptr)
    {
        if (is_null())
        {
            return m_value.emplace<T>();
        }
 
        throw JsonException(*this, error_message);
    }
 
    return *storage;
}
 
//==================================================================================================
template <typename T>
inline const T &Json::get(const char *error_message) const
{
    const auto *storage = std::get_if<T>(&m_value);
 
    if (storage == nullptr)
    {
        throw JsonException(*this, error_message);
    }
 
    return *storage;
}
 
} // namespace fly
 
//==================================================================================================
template <typename CharType>
struct fly::Formatter<fly::Json, CharType> :
    public fly::Formatter<std::basic_string<CharType>, CharType>
{
    using string_type = std::basic_string<CharType>;
 
    template <typename FormatContext>
    void format(const fly::Json &json, FormatContext &context)
    {
        if constexpr (fly::SameAs<CharType, fly::json_char_type>)
        {
            fly::Formatter<string_type, CharType>::format(json.serialize(), context);
        }
        else
        {
            auto serialized = JsonStringType::convert<string_type>(json.serialize());
 
            // The JSON string will have been validated for Unicode compliance during construction.
            fly::Formatter<string_type, CharType>::format(*serialized, context);
        }
    }
};
 
//==================================================================================================
template <>
struct std::hash<fly::Json>
{
    std::size_t operator()(const fly::Json &json) const
    {
        std::size_t type = json.m_value.index();
 
        auto visitor = [type](const auto &storage) -> std::size_t {
            using S = decltype(storage);
 
            if constexpr (fly::JsonNull<S>)
            {
                return hash_combine(type, 0);
            }
            else if constexpr (fly::JsonObject<S>)
            {
                std::hash<typename fly::json_object_type::key_type> key_hasher {};
                std::hash<typename fly::json_object_type::mapped_type> value_hasher {};
                std::size_t result = hash_combine(type, storage.size());
 
                for (const auto &value : storage)
                {
                    result = hash_combine(result, key_hasher(value.first));
                    result = hash_combine(result, value_hasher(value.second));
                }
 
                return result;
            }
            else if constexpr (fly::JsonArray<S>)
            {
                std::hash<typename fly::json_array_type::value_type> hasher {};
                std::size_t result = hash_combine(type, storage.size());
 
                for (const auto &value : storage)
                {
                    result = hash_combine(result, hasher(value));
                }
 
                return result;
            }
            else
            {
                std::hash<std::remove_cvref_t<S>> hasher {};
                return hash_combine(type, hasher(storage));
            }
        };
 
        return std::visit(std::move(visitor), json.m_value);
    }
 
private:
    static constexpr std::size_t hash_combine(std::size_t value1, std::size_t value2)
    {
        using namespace fly::literals::numeric_literals;
 
        value1 ^= value2 + 0x9e3779b9_zu + (value1 << 6_zu) + (value1 >> 2_zu);
        return value1;
    }
};