json.h

/*
 * (c) Проект "SimJson", Александр Орефков orefkov@gmail.com
 * ver. 1.0
 * Классы для работы с JSON
 * (c) Project "SimJson", Aleksandr Orefkov orefkov@gmail.com
 * ver. 1.0
 * Classes for working with JSON
 */
 
#pragma once
#include <memory>
#include <optional>
#include <vector>
#include <simstr/sstring.h>
#include <cassert>
#include <type_traits>
#include <utility>
 
#ifndef __has_declspec_attribute
#define __has_declspec_attribute(x) 0
#endif
 
#ifdef SIMJSON_IN_SHARED
    #if defined(_MSC_VER) || (defined(__clang__) && __has_declspec_attribute(dllexport))
        #ifdef SIMJSON_EXPORT
            #define SIMJSON_API __declspec(dllexport)
        #else
            #define SIMJSON_API __declspec(dllimport)
        #endif
    #elif (defined(__GNUC__) || defined(__GNUG__)) && defined(SIMSTR_EXPORT)
        #define SIMJSON_API __attribute__((visibility("default")))
    #else
        #define SIMJSON_API
    #endif
#else
    #define SIMJSON_API
#endif

namespace simjson {
using namespace simstr;
using namespace simstr::literals;
 
class Json {
public:
    enum Type {
        Undefined,
        Null,
        Boolean,
        Text,
        Integer,
        Real,
        Object,
        Array
    };
    struct null_t {};
    struct emptyString_t {};
    struct emptyObject_t {};
    struct emptyArray_t {};
 
    inline static const null_t null;
    inline static const emptyString_t emptyString;
    inline static const emptyObject_t emptyObject;
    inline static const emptyArray_t emptyArray;
};
 
enum class JsonParseResult {
    Success,
    Pending,
    NoNeedMore,
    Error,
};
 
struct StreamedJsonParserBase {
 
    unsigned line_{};
    unsigned col_{};
 
protected:
    int state_ {};
    u16s currentUnicode_[2]{};
    int idxUnicode_{};
};
 
namespace jt {
 
template<typename K>
using KeyType = StoreType<K, strhash<K>>;
 
template<typename T, typename K>
concept JsonType = std::is_integral_v<std::remove_cvref_t<T>> ||
    std::is_floating_point_v<std::remove_cvref_t<T>> ||
    std::is_constructible_v<sstring<K>, T>;
 
template<typename T, typename K>
concept JsonKeyType = std::convertible_to<T, simple_str<K>> ||
    std::same_as<std::remove_cvref_t<T>, KeyType<K>>;
 
template<typename T, typename K>
concept JsonArraySource = requires(const T& t) {
    { t.empty() } -> std::same_as<bool>;
    { t.size() } -> std::same_as<size_t>;
    { *t.begin() } -> JsonType<K>;
    { *t.end() } -> JsonType<K>;
};
 
template<typename T, typename K>
concept JsonObjectSource = requires(const T& t) {
    { t.empty() } -> std::same_as<bool>;
    { t.size() } -> std::same_as<size_t>;
    { t.begin()->first } -> JsonKeyType<K>;
    { t.end()->first } -> JsonKeyType<K>;
    { t.begin()->second } -> JsonType<K>;
    { t.end()->second } -> JsonType<K>;
};
 
} // namespace jt

template<typename K>
class JsonValueTempl : public Json {
public:
    using strType = sstring<K>;
    using ssType = simple_str<K>;
 
    using json_value = JsonValueTempl<K>;
    using obj_type = hashStrMap<K, JsonValueTempl<K>>;
    using arr_type = std::vector<JsonValueTempl<K>>;
    using json_object = std::shared_ptr<obj_type>;
    using json_array = std::shared_ptr<arr_type>;

    JsonValueTempl() : type_(Undefined) {}
    SIMJSON_API JsonValueTempl(const JsonValueTempl& other);
    JsonValueTempl(JsonValueTempl&& other) noexcept {
        type_ = other.type_;
        switch (other.type_) {
        case Json::Text:
            new (&val_.text) strType(std::move(other.val_.text));
            break;
        case Json::Object:
            new (&val_.object) json_object(std::move(other.val_.object));
            break;
        case Json::Array:
            new (&val_.array) json_array(std::move(other.val_.array));
            break;
        default:
            memcpy(&val_, &other.val_, sizeof(val_));
        }
        other.type_ = Undefined;
    }

    SIMJSON_API ~JsonValueTempl();

    JsonValueTempl(int8_t v) : type_(Integer) { val_.integer = v; }
    JsonValueTempl(int16_t v) : type_(Integer) { val_.integer = v; }
    JsonValueTempl(int32_t v) : type_(Integer) { val_.integer = v; }
    JsonValueTempl(int64_t v) : type_(Integer) { val_.integer = v; }
    JsonValueTempl(bool v) : type_(Boolean) { val_.boolean = v; }
    JsonValueTempl(double v) : type_(Real) { val_.real = v; }

    JsonValueTempl(strType t) : type_(Text) {
        new (&val_.text) strType(std::move(t));
    }

    JsonValueTempl(ssType t) : type_(Text) {
        new (&val_.text) strType(t);
    }

    template<StrExprForType<K> A>
    JsonValueTempl(const A& e) : type_(Text) {
        new (&val_.text) strType(e);
    }

    template<typename T, size_t N = const_lit_for<K, T>::Count>
    JsonValueTempl(T&& str) : type_(Text) {
        new (&val_.text) strType(std::forward<T>(str));
    }

    JsonValueTempl(const null_t&) : type_(Null) {}
    JsonValueTempl(const emptyString_t&) : type_(Text) { new (&val_.text) strType; }
    JsonValueTempl(const emptyObject_t&) : type_(Object) {
        new (&val_.object) json_object(std::make_shared<obj_type>());
    }

    JsonValueTempl(const emptyArray_t&) : type_(Array) {
        new (&val_.array) json_array(std::make_shared<arr_type>());
    }

    SIMJSON_API JsonValueTempl(Type type);
 
    struct KeyInit : std::pair<const jt::KeyType<K>, json_value> {
        using base = std::pair<const jt::KeyType<K>, json_value>;
        KeyInit(const jt::KeyType<K>& k, const json_value& v) : base(k, v){}
        KeyInit(ssType k, const json_value& v) : base(obj_type::toStoreType(k), v){}
    };
    using ObjectInit = std::initializer_list<KeyInit>;
    JsonValueTempl(ObjectInit&& init) : type_(Object) {
        new (&val_.object) json_object(std::make_shared<obj_type>(std::move(reinterpret_cast<std::initializer_list<std::pair<const jt::KeyType<K>, json_value>>&>(init))));
    }
    using ArrayInit = std::initializer_list<json_value>;
    JsonValueTempl(ArrayInit&& init) : type_(Array) {
        new (&val_.array) json_array(std::make_shared<arr_type>(std::move(init)));
    }

    JsonValueTempl(jt::JsonArraySource<K> auto const& obj) : JsonValueTempl(emptyArray) {
        if (!obj.empty()) {
            auto& arr = *as_array();
            arr.reserve(obj.size());
            for (const auto& e : obj) {
                arr.emplace_back(e);
            }
        }
    }

    JsonValueTempl(jt::JsonObjectSource<K> auto const& obj) : JsonValueTempl(emptyObject) {
        if (!obj.empty()) {
            auto& me = *as_object();
            for (const auto& [f, s] : obj) {
                me.emplace(f, s);
            }
        }
    }
 
    struct Clone {
        const json_value& from;
    };
    SIMJSON_API JsonValueTempl(const Clone& clone);
    Type type() const { return type_; }
    json_value clone() const {
        return Clone{*this};
    }
 
    // Проверка типов
    // Type checking

    bool is_undefined() const { return type_ == Undefined; };
    bool is_null() const { return type_ == Null; };
    bool is_boolean() const { return type_ == Boolean; }
    bool is_integer() const { return type_ == Integer; }
    bool is_real() const { return type_ == Real; }
    bool is_text() const { return type_ == Text; }
    bool is_array() const { return type_ == Array; }
    bool is_object() const { return type_ == Object; }
 
    // -----------------------------   Boolean -----------------------------------------------

    bool as_boolean() const {
        assert(type_ == Boolean);
        return val_.boolean;
    }

    std::optional<bool> boolean() const {
        if (type_ == Boolean) {
            return val_.boolean;
        }
        return {};
    }

    template<typename Exc, typename ... Args> requires (std::is_constructible_v<Exc, Args...>)
    bool boolean_or_throw(Args&&...args) const {
        if (type_ == Boolean) {
            return val_.boolean;
        }
        throw Exc(std::forward<Args>(args)...);
    }

    SIMJSON_API bool to_boolean() const;
 
    // ---------------------------------------- Integer -------------------------------------
    int64_t as_integer() const {
        assert(type_ == Integer);
        return val_.integer;
    }

    std::optional<int64_t> integer() const {
        if (type_ == Integer) {
            return val_.integer;
        }
        return {};
    }

    template<typename Exc, typename ... Args> requires (std::is_constructible_v<Exc, Args...>)
    int64_t integer_or_throw(Args&&...args) const {
        if (type_ == Integer) {
            return val_.integer;
        }
        throw Exc(std::forward<Args>(args)...);
    }

    SIMJSON_API std::optional<int64_t> to_integer() const;
    template<typename Exc, typename ... Args> requires (std::is_constructible_v<Exc, Args...>)
    int64_t to_integer_or_throw(Args&&...args) const {
        if (auto val = to_integer()) {
            return *val;
        }
        throw Exc(std::forward<Args>(args)...);
    }
    // -------------------------------------- Real --------------------------------------------
    double as_real() const {
        assert(type_ == Real);
        return val_.real;
    }

    std::optional<double> real() const {
        if (type_ == Real) {
            return val_.real;
        }
        return {};
    }

    template<typename Exc, typename ... Args> requires (std::is_constructible_v<Exc, Args...>)
    double real_or_throw(Args&&...args) {
        if (type_ == Real) {
            return val_.real;
        }
        throw Exc(std::forward<Args>(args)...);
    }

    SIMJSON_API double to_real() const;
    // --------------------------------------- Number -----------------------------
    // В нашей реализации в отличии от чистого json числа могут быть int64_t или double.
    // Поэтому добавим ещё логику для работы только с обоими вариантами чисел.
    // In our implementation, unlike pure json, numbers can be int64_t or double.
    // Therefore, let's add some more logic to work only with both variants of numbers.

    std::optional<int64_t> number_int() const;
    template<typename Exc, typename ... Args> requires (std::is_constructible_v<Exc, Args...>)
    int64_t number_int_or_throw(Args&&...args) const {
        if (auto val = number_int()) {
            return *val;
        }
        throw Exc(std::forward<Args>(args)...);
    }

    SIMJSON_API std::optional<double> number_real() const;
    template<typename Exc, typename ... Args> requires (std::is_constructible_v<Exc, Args...>)
    double number_real_or_throw(Args&&...args) const {
        if (auto val = number_real()) {
            return *val;
        }
        throw Exc(std::forward<Args>(args)...);
    }
 
    // --------------------------------------- Text -----------------------------

    const strType& as_text() const {
        assert(type_ == Text);
        return val_.text;
    }

    std::optional<strType> text() const {
        if (type_ == Text) {
            return val_.text;
        }
        return {};
    }

    template<typename Exc, typename ... Args> requires (std::is_constructible_v<Exc, Args...>)
    const strType& text_or_throw(Args&&...args) const {
        if (type_ == Text) {
            return val_.text;
        }
        throw Exc(std::forward<Args>(args)...);
    }

    template<typename Exc, typename ... Args> requires (std::is_constructible_v<Exc, Args...>)
    const strType& not_empty_text_or_throw(Args&&...args) const {
        if (type_ == Text && !val_.text.template trimmed<ssType>().is_empty()) {
            return val_.text;
        }
        throw Exc(std::forward<Args>(args)...);
    }

    SIMJSON_API strType to_text() const;

    json_object& as_object() {
        assert(type_ == Object);
        return val_.object;
    }

    const json_object& as_object() const {
        assert(type_ == Object);
        return val_.object;
    }

    json_array& as_array() {
        assert(type_ == Array);
        return val_.array;
    }

    const json_array& as_array() const {
        assert(type_ == Array);
        return val_.array;
    }

    void swap(json_value& other) noexcept {
        char tmp[sizeof(*this)];
        memcpy(tmp, this, sizeof(*this));
        memcpy((void*)this, &other, sizeof(*this));
        memcpy((void*)&other, tmp, sizeof(*this));
    }

    JsonValueTempl& operator=(json_value t) noexcept {
        swap(t);
        return *this;
    }

    template<jt::JsonKeyType<K> T>
    const json_value& at(T&& key) const {
        if (type_ == Object) {
            if (auto it = as_object()->find(std::forward<T>(key)); it != as_object()->end())
                return it->second;
        }
        return UNDEFINED;
    }

    template<jt::JsonKeyType<K> T>
    const json_value& operator[](T&& key) const {
        return at(std::forward<T>(key));
    }

    template<jt::JsonKeyType<K> T, typename...Args>
    const json_value& operator()(T&& key, Args&&...args) const {
        const json_value& res = at(std::forward<T>(key));
        if constexpr (sizeof...(Args) == 0) {
            return res;
        } else {
            return res.is_undefined() ? res : res(std::forward<Args>(args)...);
        }
    }

    template<jt::JsonKeyType<K> T>
    json_value& operator[](T&& key) {
        if (type_ != Object) {
            assert(this != &UNDEFINED);
            *this = emptyObject;
        }
        return as_object()->try_emplace(std::forward<T>(key)).first->second;
    }

    template<jt::JsonKeyType<K> Key, typename ... Args>
    json_value& set(Key&& key, Args&& ... args) {
        if (type_ != Object) {
            assert(this != &UNDEFINED);
            *this = emptyObject;
        }
        return as_object()->emplace(std::forward<Key>(key), std::forward<Args>(args)...).first->second;
    }

    const json_value& at(size_t idx) const {
        if (type_ == Array) {
            const auto& arr = *as_array();
            if (idx < arr.size()) {
                return arr[idx];
            }
        }
        return UNDEFINED;
    }

    const json_value& operator[](size_t idx) const {
        return at(idx);
    }

    json_value& operator[](size_t idx) {
        if (type_ != Array) {
            assert(this != &UNDEFINED);
            *this = emptyArray;
        }
        auto& arr = *as_array();
        if (idx == -1) {
            idx = arr.size();
        }
        if (idx >= arr.size()) {
            arr.resize(idx + 1);
        }
        return arr[idx];
    }

    size_t size() const {
        if (type_ == Array) {
            return as_array()->size();
        } else if (type_ == Object) {
            return as_object()->size();
        }
        return 0;
    }

    SIMJSON_API void merge(const json_value& other, bool replace = true, bool append_arrays = false);
    static std::tuple<json_value, JsonParseResult, unsigned, unsigned> parse(ssType jsonString);
    SIMJSON_API void store(lstring<K, 0, true>& stream, bool prettify = false, bool order_keys = false, K indent_symbol = ' ', unsigned indent_count = 2) const;
    lstring<K, 0, true> store(bool prettify = false, bool order_keys = false, K indent_symbol = ' ', unsigned indent_count = 2) const {
        lstring<K, 0, true> res;
        store(res, prettify, order_keys, indent_symbol, indent_count);
        return res;
    }
 
protected:
    SIMJSON_API static const json_value UNDEFINED;
 
    // Тип значения
    Type type_;
    // Хранимое значение
    union Value {
        Value() : boolean(false){}
        ~Value(){}
        bool boolean;
        int64_t integer;
        double real;
        strType text;
        json_object object;
        json_array array;
    } val_;
};

template<typename K>
struct StreamedJsonParser : StreamedJsonParserBase {
 
    JsonValueTempl<K> result_;
 
    using strType = typename JsonValueTempl<K>::strType;
    using ssType = typename JsonValueTempl<K>::ssType;
 
    void reset() {
        this->~StreamedJsonParser<K>();
        new (this) StreamedJsonParser<K>;
    }
    JsonParseResult parseAll(ssType text) {
        return process<true, true>(text);
    }

    JsonParseResult processChunk(ssType chunk, bool last) {
        return last ? process<false, true>(chunk) : process<false, false>(chunk);
    }
 
protected:
 
    template<bool All, bool Last>
    SIMJSON_API JsonParseResult process(ssType chunk);
 
    static bool isWhiteSpace(K symbol) {
        return symbol == ' ' || symbol == '\t' || symbol == '\n' || symbol == '\r';
    }
 
    strType getText();
    bool processUnicode(K symbol);
 
    template<bool Compound, int NewState, typename ... Args>
    JsonValueTempl<K>* addValue(JsonValueTempl<K>* current, Args&& ... args);
 
    JsonValueTempl<K>* popStack();
 
    template<bool asInt, bool All>
    JsonValueTempl<K>* addNumber(JsonValueTempl<K>* current);
 
    const K* ptr_{};
    const K* startProcess_ {};
    std::vector<JsonValueTempl<K>*> stack_{&result_};
    chunked_string_builder<K> text_{512};
};
 
template<typename K>
std::tuple<JsonValueTempl<K>, JsonParseResult, unsigned, unsigned> JsonValueTempl<K>::parse(ssType jsonString) {
    StreamedJsonParser<K> parser;
    auto res = parser.parseAll(jsonString);
    return {std::move(parser.result_), res, parser.line_, parser.col_};
}

using JsonValue = JsonValueTempl<u8s>;
using JsonValueW = JsonValueTempl<uws>;
using JsonValueU = JsonValueTempl<u16s>;
using JsonValueUU = JsonValueTempl<u32s>;

#if defined (SIMJSON_EXPORT) || !defined (SIMJSON_IN_SHARED)
template<typename K>
inline SIMJSON_API const JsonValueTempl<K> JsonValueTempl<K>::UNDEFINED;
#else
#endif

SIMJSON_API stringa get_file_content(stra filePath);
 
} // namespace simjson