Meojson

#include <meojson/json.hpp>

auto opt = json::parse(str);      // std::optional<json::value>
auto file = json::open(path);     // 从文件读取
auto jsonc = json::parsec(str);   // JSONC，支持注释

template <typename T>
T ParseParam(const char* text)
{
    if (text == nullptr || std::strlen(text) == 0) {
        return T {};
    }

    auto opt = json::parse(text);
    if (!opt) {
        LogError << "failed to parse json param" << VAR(text);
        return T {};
    }

    T result {};
    if (!result.from_json(*opt)) {
        LogError << "failed to deserialize json param" << VAR(text);
        return T {};
    }
    return result;
}

json::parse(str).value_or(json::object {}).as<T>();

json::value v1 = 42;
json::value v2 = "hello";
json::value v3 = true;
json::value v4 = nullptr;

json::array arr { 1, 2, "three" };
json::object obj {
    { "key1", "value1" },
    { "key2", 42 },
};

std::vector<int> vec = { 1, 2, 3 };
json::value v5 = vec;

std::map<std::string, int> map = { { "a", 1 } };
json::value v6 = map;

v.is_null();
v.is_boolean();
v.is_number();
v.is_string();
v.is_array();
v.is_object();
v.is<int>();

v.as_string();
v.as_string_view();
v.as_integer();
v.as_double();
v.as_boolean();
v.as_array();
v.as_object();
v.as<T>();

auto name = v.find<std::string>("name");
if (name) {
    // use *name
}

std::string label = v.get("label", "default");
int count = v.get("config", "count", 0);

if (v.exists("key")) {
    // ...
}

v.dumps();       // 紧凑字符串
v.dumps(4);      // 4 空格缩进
v.format();      // pretty print

template <typename T>
void WriteJsonDetail(MaaStringBuffer* out_detail, const T& payload)
{
    if (out_detail == nullptr) {
        return;
    }
    const std::string json_text = json::value(payload).dumps();
    MaaStringBufferSet(out_detail, json_text.c_str());
}

json::value merged = obj1 | obj2;  // 右侧覆盖同名键
obj1 |= obj2;

struct LocateOutput {
    int status = 0;
    std::string message;
    std::string map_name;
    int x = 0;
    int y = 0;

    MEO_JSONIZATION(status, message, MEO_OPT map_name, MEO_OPT x, MEO_OPT y)
};

json::value j = data;

LocateOutput data {};
if (!data.from_json(j)) {
    LogError << "failed to deserialize" << VAR(j);
}

struct Options {
    double threshold = 0.7;
    bool enabled = true;

    MEO_JSONIZATION(MEO_OPT threshold, MEO_OPT enabled)
};

struct TemplateParam {
    std::vector<std::string> template_;

    MEO_JSONIZATION(MEO_KEY("template") template_)
};

MEO_OPT MEO_KEY("default") default_

namespace json::ext {
template <>
class jsonization<MyRect> {
public:
    json::value to_json(const MyRect& rect) const
    {
        return json::array { rect.x, rect.y, rect.width, rect.height };
    }

    bool check_json(const json::value& value) const
    {
        return value.is<std::vector<int>>() && value.as_array().size() == 4;
    }

    bool from_json(const json::value& value, MyRect& rect) const
    {
        auto arr = value.as<std::vector<int>>();
        rect = MyRect { arr[0], arr[1], arr[2], arr[3] };
        return true;
    }
};
}

enum class MyEnum {
    A,
    B,
    C,
    MEOJSON_ENUM_RANGE(A, C)
};

json::value j = MyEnum::B;
MyEnum e = j.as<MyEnum>();