json.h

Go to the documentation of this file.

#ifndef csc_json_H_
#define csc_json_H_
 
#include "Util/conscience_log.h"
 
#include <any>
#include <variant>
#include <exception>
#include <filesystem>
#include <memory>
#include <optional>
#include <type_traits>
#include <typeinfo>
#include <yyjson.h>
 
using std::string, std::optional, std::exception, std::unique_ptr, std::vector, std::any, std::make_shared;
namespace fs = std::filesystem;
template <class T>
using ptr = std::shared_ptr<T>;
 
using namespace conscience_utils;
 
namespace conscience_utils::JSON {
 
#define JSON_BASE_TYPES std::nullptr_t, const char *, char *, bool, unsigned, int, long long, unsigned long long, string, float, double
 
struct JsonSerializableData;
 
using JsonArray = std::vector<JsonSerializableData>;
using JsonObject = std::map<std::string, JsonSerializableData>;
struct JsonArrayBox {
    JsonArray value;
};
 
struct JsonObjectBox {
    JsonObject value;
};
 
using JsonValue = std::variant<
    JSON_BASE_TYPES,
    JsonArrayBox,
    JsonObjectBox>;
 
namespace typing_helper {
template <class T>
using decay_t = std::decay_t<T>;
 
template <class T>
inline constexpr bool is_scalar_json_v =
    std::is_same_v<decay_t<T>, std::nullptr_t> ||
    std::is_same_v<decay_t<T>, const char*> ||
    std::is_same_v<decay_t<T>, char*> ||
    std::is_same_v<decay_t<T>, bool> ||
    std::is_same_v<decay_t<T>, unsigned> ||
    std::is_same_v<decay_t<T>, int> ||
    std::is_same_v<decay_t<T>, long long> ||
    std::is_same_v<decay_t<T>, unsigned long long> ||
    std::is_same_v<decay_t<T>, std::string> ||
    std::is_same_v<decay_t<T>, float> ||
    std::is_same_v<decay_t<T>, double>;
 
template <class T>
inline constexpr bool excluded_v =
    std::is_same_v<decay_t<T>, JsonSerializableData> ||
    std::is_same_v<decay_t<T>, JsonObject::value_type> ||
    std::is_same_v<decay_t<T>, JsonArray> ||
    std::is_same_v<decay_t<T>, JsonObject>;
 
} 
 
struct JsonSerializableData {
public:
    JsonValue value;
 
    JsonSerializableData() = default;
    JsonSerializableData(const JsonSerializableData&) = default;
    JsonSerializableData(JsonSerializableData&&) noexcept = default;
    JsonSerializableData& operator=(const JsonSerializableData&) = default;
    JsonSerializableData& operator=(JsonSerializableData&&) noexcept = default;
 
    // enums -> store as (u)int64 to keep std::variant construction stable across platforms
    template <class E>
    requires (std::is_enum_v<typing_helper::decay_t<E>> && !typing_helper::excluded_v<E>)
    JsonSerializableData(E&& e) {
        using U = std::underlying_type_t<typing_helper::decay_t<E>>;
        if constexpr (std::is_signed_v<U>) {
            value = static_cast<long long>(static_cast<U>(e));
        } else {
            value = static_cast<unsigned long long>(static_cast<U>(e));
        }
    }
 
    // scalar json types (non-enum)
    template <class T>
    requires (!std::is_enum_v<typing_helper::decay_t<T>> &&
              typing_helper::is_scalar_json_v<T> &&
              !typing_helper::excluded_v<T>)
    JsonSerializableData(T&& v)
        : value(std::forward<T>(v)) {
    }
 
    // array
    JsonSerializableData(const JsonArray& v)
        : value(JsonArrayBox{v}) {
    }
 
    JsonSerializableData(JsonArray&& v)
        : value(JsonArrayBox{std::move(v)}) {
    }
 
    // object
    JsonSerializableData(const JsonObject& v)
        : value(JsonObjectBox{v}) {
    }
 
    JsonSerializableData(JsonObject&& v)
        : value(JsonObjectBox{std::move(v)}) {
    }
 
    JsonSerializableData(std::initializer_list<JsonObject::value_type> init)
        : value(JsonObjectBox{JsonObject(init)}) {
    }
 
    JsonSerializableData(std::initializer_list<JsonSerializableData> init)
        : value(JsonArrayBox{JsonArray(init)}) {
    }
 
    operator JsonValue&() {
        return value;
    }
};
 
string vectorToJson(const vector<JsonSerializableData> &list, bool noNewLines = false);
string mapToJson(
    std::initializer_list<JsonObject::value_type> init,
    bool noNewLines = false);
string mapToJson(const map<string, JsonSerializableData> &entries, bool noNewLines = false);
string pairsToJson(const vector<pair<string, JsonSerializableData>> &entries, bool noNewLines = false);
string jsonSerializableDataToString(JsonSerializableData data);
 
template <class TValue>
JsonSerializableData vectorToJsonSerializable(const vector<TValue> &theVector) {
    JsonArray out;
    out.reserve(theVector.size());
    for (const auto &v : theVector) {
        out.emplace_back(static_cast<TValue>(v));
    }
    return JsonSerializableData(std::move(out));
}
 
inline map<string, JsonSerializableData>
mapToJsonSerializable(
    std::initializer_list<map<string, JsonSerializableData>::value_type> init) {
    return map<string, JsonSerializableData>(init);
}
 
template <class TValue>
map<string, JsonSerializableData> mapToJsonSerializable(const map<string, TValue> &theMap) {
    map<string, JsonSerializableData> mapCopy;
    for (auto entry : theMap) {
        mapCopy[entry.first] = entry.second;
    }
    return mapCopy;
}
 
class MissingRequiredPropertyException : public exception {
public:
    MissingRequiredPropertyException(const string message) throw()
        : message(message) {
    }
 
    const char *what() const throw() {
        return message.c_str();
    }
 
    const string getMessage() const {
        return message;
    }
 
private:
    const string message;
};
 
template <class T>
T getNumericValueFromJson(yyjson_val *jsonValue) {
    ASSERT("given value is not numeric - " + to_string(yyjson_get_type(jsonValue)), yyjson_get_type(jsonValue) == YYJSON_TYPE_NUM);
    switch (yyjson_get_subtype(jsonValue)) {
    case YYJSON_SUBTYPE_UINT:
        return (T)yyjson_get_uint(jsonValue);
    case YYJSON_SUBTYPE_SINT:
        return (T)yyjson_get_sint(jsonValue);
    default:
    case YYJSON_SUBTYPE_REAL:
        return (T)yyjson_get_real(jsonValue);
    }
}
 
class CscJsonObject;
 
class CscJsonObjectReader {
public:
    vector<string> getKeys();
 
    bool hasKey(const string &key);
 
    bool isArray(const string &key);
 
    unsigned getArrayLength(const string &arrayKey);
 
    bool isNull(const string &key);
 
    string getRequiredStringValue(const string &key, bool allowEmpty = false);
 
    optional<int> getIntValue(const string &key);
 
    int getRequiredIntValue(const string &key);
 
    optional<unsigned long long> getUnsignedLongValue(const string &key);
 
    unsigned long long getRequiredUnsignedLongValue(const string &key);
 
    optional<bool> getBooleanValue(const string &key);
 
    bool getRequiredBooleanValue(const string &key);
 
    optional<double> getDoubleValue(const string &key);
 
    double getRequiredDoubleValue(const string &key);
 
    optional<float> getFloatValue(const string &key);
 
    float getRequiredFloatValue(const string &key);
 
    optional<string> getStringValue(const string &key);
 
    CscJsonObjectReader getRequiredObjectValue(const string &key);
 
    optional<CscJsonObjectReader> getObjectValue(const string &key);
 
    CscJsonObjectReader *getRequiredObjectPtrValue(const string &key);
 
    optional<CscJsonObjectReader *> getObjectPtrValue(const string &key);
 
    ptr<CscJsonObjectReader> getRequiredObjectSharedPtrValue(const string &key);
 
    optional<ptr<CscJsonObjectReader>> getObjectSharedPtrValue(const string &key);
 
    map<string, optional<any>> getRequiredObjectValueAsMap(const string &key);
 
    map<string, string> getRequiredObjectValueAsMapOfStrings(const string &key);
 
    optional<map<string, optional<any>>> getObjectValueAsMap(const string &key);
 
    optional<any> getAnyValue(string key);
 
    template <class T>
    vector<T> getRequiredArrayValue(const string &key) {
        optional<vector<T>> value = getArrayValue<T>(key);
        if (!value.has_value()) {
            throw MissingRequiredPropertyException("required array property " + key + " cannot be found in " + toString());
        }
 
        return value.value();
    }
 
    template <class T>
    optional<vector<T>> getArrayValue(const string &key) {
        try {
            yyjson_val *value = getValueByPropertyPath(key);
            return toArrayValue<T>(value, getYyjsonDoc());
        } catch (const std::invalid_argument e) {
            LOG_WARN(key + " cannot be read as array: " + string(e.what()));
        }
        return {};
    }
 
    template <class T>
    optional<T> getArrayItemValue(const string &arrayKey, size_t index) {
        optional<T> result = {};
        try {
            yyjson_val *value = getValueByPropertyPath(arrayKey);
            if (value != nullptr) {
                yyjson_val *itemValue = yyjson_arr_get(value, index);
                if (itemValue != nullptr) {
                    result = toValue<T>(itemValue, getYyjsonDoc());
                }
            }
        } catch (const std::invalid_argument e) {
            LOG_WARN("cannot getArrayItemValue " + arrayKey + " : " + string(e.what()));
        }
        return result;
    }
    template <class T>
    T getRequiredArrayItemValue(const string &arrayKey, size_t index) {
        optional<T> value = getArrayItemValue<T>(arrayKey, index);
        if (!value.has_value()) {
            throw MissingRequiredPropertyException("required array item: " + arrayKey + "[" + to_string(index) + "] cannot be found in " + toString());
        }
 
        return value.value();
    }
 
    template <class T>
    vector<T> asArrayValue() {
        return toArrayValue<T>(getYyjsonValue(), getYyjsonDoc()).value();
    }
 
    CscJsonObjectReader(ptr<yyjson_doc> yyjsonDoc, yyjson_val *yyjsonValue = nullptr, bool doNotReleaseYyjsonObjects = false);
    CscJsonObjectReader(const fs::path filePath);
    CscJsonObjectReader(const string &jsonContent);
 
    virtual ~CscJsonObjectReader();
 
    string toString();
 
    string toJsonString(bool prettyPrint = false);
 
    CscJsonObject *toMutable(yyjson_mut_doc *parentDoc = nullptr);
    static vector<CscJsonObject *> toMutableList(const vector<ptr<CscJsonObjectReader>> values);
 
    yyjson_val *getLowLevelParser();
 
protected:
    static ptr<yyjson_doc> createYyjsonSharedPtr(yyjson_doc *doc);
    ptr<yyjson_doc> yyjsonDoc = nullptr;
 
    yyjson_val *yyjsonValue = nullptr;
    virtual ptr<yyjson_doc> getYyjsonDoc();
    virtual yyjson_val *getYyjsonValue();
 
    yyjson_val *getValueByPropertyPath(const string &propertyPath);
    static yyjson_doc *parseFromFile(const fs::path filePath);
    static yyjson_doc *parseFromString(const string &jsonString);
 
private:
    const bool doNotReleaseYyjsonObjects;
 
    optional<any> jsonValueToAny(yyjson_val *jsonValue);
 
    template <class T>
    static inline T toValue(yyjson_val *yyjsonValue, ptr<yyjson_doc> jsonDoc) {
        if constexpr (std::is_arithmetic<T>::value) {
            return getNumericValueFromJson<T>(yyjsonValue);
        }
        if constexpr (std::is_same<T, string>::value) {
            const char *valueChars = yyjson_get_str(yyjsonValue);
            return string(valueChars);
        }
        if constexpr (std::is_same_v<T, const CscJsonObjectReader *> || std::is_same_v<T, CscJsonObjectReader *>) {
            return new CscJsonObjectReader(jsonDoc, yyjsonValue, true);
        }
        if constexpr (std::is_base_of<ptr<CscJsonObjectReader>, T>::value) {
            return std::make_shared<CscJsonObjectReader>(jsonDoc, yyjsonValue, true);
        }
        throw new std::invalid_argument(
            "unsupported data type " + string(typeid(T).name()) + " for array " +
            string(yyjsonValue != nullptr ? string(yyjson_get_raw(yyjsonValue)) : "?"));
    }
 
    template <class T>
    static optional<vector<T>> toArrayValue(yyjson_val *arrayJsonValue, ptr<yyjson_doc> jsonDoc) {
        try {
            if (arrayJsonValue != nullptr && yyjson_get_type(arrayJsonValue) == YYJSON_TYPE_ARR) {
                vector<T> items;
 
                string ss = string(yyjson_val_write(arrayJsonValue, YYJSON_WRITE_NOFLAG, NULL));
 
                yyjson_val *arrayItem;
                yyjson_arr_iter iter = yyjson_arr_iter_with(arrayJsonValue);
                while ((arrayItem = yyjson_arr_iter_next(&iter))) {
                    items.push_back(toValue<T>(arrayItem, jsonDoc));
                }
 
                return items;
            }
        } catch (const std::invalid_argument e) {
            LOG_WARN(string(arrayJsonValue != nullptr ? string(yyjson_get_raw(arrayJsonValue)) : "?") + " cannot be read as array: " + string(e.what()));
        }
        return {};
    }
};
 
class CscJsonParser : public CscJsonObjectReader {
public:
    CscJsonParser(const fs::path &filePath);
    CscJsonParser(const string &jsonContent);
};
 
class CscJsonObject : public CscJsonObjectReader {
public:
    CscJsonObject(const fs::path &jsonFilePath);
    CscJsonObject(const string &jsonString);
 
    CscJsonObject(const map<string, string> &map);
 
    CscJsonObject(yyjson_mut_doc *existingDoc, yyjson_mut_val *existingValue, bool doNotReleaseYyjsonObjects = false, CscJsonObject *lookupParent = nullptr);
 
    CscJsonObject();
    ~CscJsonObject();
 
    CscJsonObject getRequiredObjectMutableValue(const string &key);
 
    optional<CscJsonObject> getObjectMutableValue(const string &key);
 
    CscJsonObject *getRequiredObjectMutablePtrValue(const string &key);
 
    optional<CscJsonObject *> getObjectMutablePtrValue(const string &key);
 
    ptr<CscJsonObject> getRequiredObjectMutableSharedPtrValue(const string &key);
 
    optional<ptr<CscJsonObject>> getObjectMutableSharedPtrValue(const string &key);
 
    CscJsonObject *set(const string &propertyPath, bool value);
    CscJsonObject *set(const string &propertyPath, const char *value);
    CscJsonObject *set(const string &propertyPath, const string &value);
    CscJsonObject *set(const string &propertyPath, double value);
    CscJsonObject *set(const string &propertyPath, int value);
    CscJsonObject *set(const string &propertyPath, long long value);
    CscJsonObject *set(const string &propertyPath, unsigned long long value);
    CscJsonObject *set(const string &propertyPath, CscJsonObject &object);
    CscJsonObject *set(const string &propertyPath, CscJsonObject *object);
    CscJsonObject *set(const string &propertyPath, ptr<CscJsonObject> object);
    CscJsonObject *set(const string &propertyPath, const map<string, string> &value);
 
    CscJsonObject *setArray(const string &propertyPath, const vector<bool> &value);
    CscJsonObject *setArray(const string &propertyPath, const vector<string> &value);
    CscJsonObject *setArray(const string &propertyPath, const vector<float> &value);
    CscJsonObject *setArray(const string &propertyPath, const vector<double> &value);
    CscJsonObject *setArray(const string &propertyPath, const vector<int> &value);
    CscJsonObject *setArray(const string &propertyPath, const vector<long long> &value);
    CscJsonObject *setArray(const string &propertyPath, const vector<unsigned long long> &value);
    CscJsonObject *setArray(const string &propertyPath, const vector<CscJsonObject *> &objects);
    CscJsonObject *setArray(const string &propertyPath, const vector<CscJsonObject> &objects);
    CscJsonObject *setArray(const string &propertyPath, const vector<ptr<CscJsonObject>> &objects);
    CscJsonObject *setArray(const string &propertyPath, const vector<map<string, string>> &value);
 
    CscJsonObject *remove(const string &propertyPath);
 
    void saveToFile(const fs::path &outPath, bool lineBreakAndTabulation = false);
 
    static string addLineBreakAndTabulation(const string &json);
 
    yyjson_mut_val *getLowLevelMutableObject();
 
    void mergeWith(CscJsonObject &other, bool deep = true);
 
    void mergeKeyWith(CscJsonObject &other, const string &subPropertyPath, bool deep = true);
 
private:
    bool doNotReleaseYyjsonObjects = false;
    void onModified();
    CscJsonObject *lookupParent = nullptr;
 
protected:
    yyjson_mut_doc *yyjsonMutableDoc = nullptr;
 
    yyjson_mut_val *yyjsonMutableValue = nullptr;
 
    virtual yyjson_val *getYyjsonValue() override;
    virtual ptr<yyjson_doc> getYyjsonDoc() override;
    yyjson_mut_doc *getYyjsonMutableDoc();
    yyjson_mut_val *getYyjsonMutableValue();
 
    yyjson_mut_val *getMutableValueByPropertyPath(const string &propertyPath);
 
    yyjson_mut_val *getOrCreateObjectByPropertyPath(const string &propertyPath);
 
    CscJsonObject *set(const string &propertyPath, yyjson_mut_val *newValue);
 
    void mergeObjects(yyjson_mut_val *thisObj, yyjson_mut_val *otherObj, bool deep);
};
 
template <class T>
concept IsString = std::is_same_v<T, string>;
template <IsString T>
yyjson_mut_val *toJsonValue(const T &value, yyjson_mut_doc *doc) {
    char *stringCopy = strdup(value.c_str());
    return yyjson_mut_str(doc, stringCopy);
}
 
template <class T>
concept IsNotString = !IsString<T>;
template <IsNotString T>
yyjson_mut_val *toJsonValue(const T &value, yyjson_mut_doc *doc);
 
inline yyjson_mut_val *mapToJsonObject(const map<string, string> &map, yyjson_mut_doc *doc) {
    yyjson_mut_val *mapJsonValue = yyjson_mut_obj(doc);
 
    for (auto [key, value] : map) {
        yyjson_mut_val *keyJsonValue = toJsonValue(key, doc);
        yyjson_mut_val *valueJsonValue = toJsonValue(value, doc);
        yyjson_mut_obj_put(mapJsonValue, keyJsonValue, valueJsonValue);
    }
 
    return mapJsonValue;
}
 
template <IsNotString T>
yyjson_mut_val *toJsonValue(T &value, yyjson_mut_doc *doc) {
 
    if constexpr (std::is_arithmetic<T>::value) {
        if constexpr (std::is_unsigned<T>::value) {
            return yyjson_mut_uint(doc, value);
        } else if constexpr (std::is_floating_point<T>::value) {
            return yyjson_mut_real(doc, value);
        } else {
            return yyjson_mut_sint(doc, value);
        }
 
    } else if constexpr (std::is_same_v<T, bool>) {
        return yyjson_mut_bool(doc, value);
 
    } else if constexpr (std::is_same_v<ptr<CscJsonObject>, T> || std::is_same_v<ptr<const CscJsonObject>, T>) {
        return yyjson_mut_val_mut_copy(doc, value->getLowLevelMutableObject());
 
    } else if constexpr (std::is_same_v<CscJsonObject, T>) {
        return yyjson_mut_val_mut_copy(doc, value.getLowLevelMutableObject());
 
    } else if constexpr (std::is_same_v<CscJsonObject *, T> || std::is_same_v<const CscJsonObject *, T>) {
        return yyjson_mut_val_mut_copy(doc, value->getLowLevelMutableObject());
 
    } else if constexpr (std::is_same_v<map<string, string>, T>) {
        return mapToJsonObject(value, doc);
    } else {
        throw runtime_error("unsupported type ");
    }
}
 
template <class T>
yyjson_mut_val *toJsonValue(const vector<T> &valueList, yyjson_mut_doc *doc, bool clone = false) {
    yyjson_mut_val *arrayValue = yyjson_mut_arr(doc);
    for (T value : valueList) {
        yyjson_mut_val *jsonValue = toJsonValue<T>(value, doc);
        yyjson_mut_val *newValue = jsonValue;
        if (clone) {
            newValue = yyjson_mut_val_mut_copy(doc, jsonValue);
        }
        bool success = yyjson_mut_arr_append(arrayValue, newValue);
        if (!success) {
            throw runtime_error("cannot add item to array");
        }
    }
    return arrayValue;
}
 
}
 
#endif