korenkonder_ReDIVA/src/KKdLib/msgpack.hpp

/*
    by korenkonder
    GitHub/GitLab: korenkonder
*/

#pragma once

#include <string>
#include <vector>
#include "default.hpp"
#include "prj/vector_pair.hpp"

enum msgpack_type : uint32_t {
    MSGPACK_NONE = 0,
    MSGPACK_NULL,
    MSGPACK_BOOL,
    MSGPACK_INT8,
    MSGPACK_UINT8,
    MSGPACK_INT16,
    MSGPACK_UINT16,
    MSGPACK_INT32,
    MSGPACK_UINT32,
    MSGPACK_INT64,
    MSGPACK_UINT64,
    MSGPACK_FLOAT32,
    MSGPACK_FLOAT64,
    MSGPACK_STRING,
    MSGPACK_ARRAY,
    MSGPACK_MAP,
};

struct msgpack;

typedef std::vector<msgpack> msgpack_array;
typedef prj::vector_pair<std::string, msgpack> msgpack_map;

union msgpack_data {
    bool b;
    int8_t i8;
    uint8_t u8;
    int16_t i16;
    uint16_t u16;
    int32_t i32;
    uint32_t u32;
    int64_t i64;
    uint64_t u64;
    float_t f32;
    double_t f64;
    std::string* str;
    msgpack_array* arr;
    msgpack_map* map;
};

struct msgpack {
    msgpack_type type;
    msgpack_data data;

    _Ret_maybenull_ msgpack* get_by_index(_In_ size_t index);
    void set_by_index(_In_ msgpack* m, _In_ size_t index);
    _Ret_maybenull_ msgpack* get_by_name(_In_z_ const char* name);
    void set_by_name(_In_z_ const char* name, _In_ msgpack* m);
    _Ret_maybenull_ msgpack* append(_In_z_ const char* name, _Inout_ msgpack* m);
    _Ret_maybenull_ msgpack* append(_In_z_ const char* name, _Inout_ msgpack& m);
    _Ret_maybenull_ msgpack* append(_In_z_ const char* name, _Inout_ msgpack&& m);
    _Ret_maybenull_ msgpack* read(_In_opt_z_ const char* name);
    _Ret_maybenull_ msgpack* read(_In_opt_z_ const char* name, _In_ msgpack_type type);
    _Ret_maybenull_ msgpack* read_array(_In_opt_z_ const char* name = 0);
    _Ret_maybenull_ msgpack* read_map(_In_opt_z_ const char* name = 0);
    bool read_bool(_In_opt_z_ const char* name = 0);
    int8_t read_int8_t(_In_opt_z_ const char* name = 0);
    uint8_t read_uint8_t(_In_opt_z_ const char* name = 0);
    int16_t read_int16_t(_In_opt_z_ const char* name = 0);
    uint16_t read_uint16_t(_In_opt_z_ const char* name = 0);
    int32_t read_int32_t(_In_opt_z_ const char* name = 0);
    uint32_t read_uint32_t(_In_opt_z_ const char* name = 0);
    int64_t read_int64_t(_In_opt_z_ const char* name = 0);
    uint64_t read_uint64_t(_In_opt_z_ const char* name = 0);
    float_t read_float_t(_In_opt_z_ const char* name = 0);
    double_t read_double_t(_In_opt_z_ const char* name = 0);
    _Check_return_ _Ret_maybenull_z_ char* read_utf8_string(_In_opt_z_ const char* name = 0);
    _Check_return_ _Ret_maybenull_z_ wchar_t* read_utf16_string(_In_opt_z_ const char* name = 0);
    std::string read_string(_In_opt_z_ const char* name = 0);
    std::wstring read_wstring(_In_opt_z_ const char* name = 0);

    msgpack& operator=(const msgpack& m);

    inline msgpack() : data() {
        type = MSGPACK_NULL;
    }

    inline msgpack(const msgpack& m) : type(), data() {
        *this = m;
    }

    inline msgpack(msgpack_array& val) : data() {
        type = MSGPACK_ARRAY;
        data.arr = new msgpack_array;
        data.arr->assign(val.begin(), val.end());
        val.clear();
        val.shrink_to_fit();
    }

    inline msgpack(msgpack_array&& val) : data() {
        type = MSGPACK_ARRAY;
        data.arr = new msgpack_array;
        data.arr->assign(val.begin(), val.end());
        val.clear();
        val.shrink_to_fit();
    }

    inline msgpack(msgpack_map& val) : data() {
        type = MSGPACK_MAP;
        data.map = new msgpack_map;
        data.map->assign(val.begin(), val.end());
        val.clear();
        val.shrink_to_fit();
    }
    inline msgpack(msgpack_map&& val) : data() {
        type = MSGPACK_MAP;
        data.map = new msgpack_map;
        data.map->assign(val.begin(), val.end());
        val.clear();
        val.shrink_to_fit();
    }

    inline msgpack(bool val) : data() {
        type = MSGPACK_BOOL;
        data.b = val;
    }

    inline msgpack(int8_t val) : data() {
        type = MSGPACK_INT8;
        data.i64 = val;
    }

    inline msgpack(uint8_t val) : data() {
        type = MSGPACK_UINT8;
        data.u64 = val;
    }

    inline msgpack(int16_t val) : data() {
        type = MSGPACK_INT16;
        data.i64 = val;
    }

    inline msgpack(uint16_t val) : data() {
        type = MSGPACK_UINT16;
        data.u64 = val;
    }

    inline msgpack(int32_t val) : data() {
        type = MSGPACK_INT32;
        data.i64 = val;
    }

    inline msgpack(uint32_t val) : data() {
        type = MSGPACK_UINT32;
        data.u64 = val;
    }

    inline msgpack(int64_t val) : data() {
        type = MSGPACK_INT64;
        data.i64 = val;
    }

    inline msgpack(uint64_t val) : data() {
        type = MSGPACK_UINT64;
        data.u64 = val;
    }

    inline msgpack(float_t val) : data() {
        type = MSGPACK_FLOAT32;
        data.f32 = val;
    }

    inline msgpack(double_t val) : data() {
        type = MSGPACK_FLOAT64;
        data.f64 = val;
    }

    inline msgpack(const char* val) : data() {
        type = MSGPACK_STRING;
        data.str = new std::string;
        if (val)
            data.str->assign(val);
    }

    inline msgpack(const wchar_t* val) : data() {
        type = MSGPACK_STRING;
        data.str = new std::string;
        if (val) {
            char* temp = utf16_to_utf8(val);
            if (temp)
                data.str->assign(temp);
            free_def(temp);
        }
    }

    inline msgpack(const std::string& val) : data() {
        type = MSGPACK_STRING;
        data.str = new std::string;
        if (val.size())
            data.str->assign(val);
    }

    inline msgpack(const std::string&& val) : data() {
        type = MSGPACK_STRING;
        data.str = new std::string;
        if (val.size())
            data.str->assign(val);
    }

    inline msgpack(const std::wstring& val) : data() {
        type = MSGPACK_STRING;
        data.str = new std::string;
        if (val.size()) {
            char* temp = utf16_to_utf8(val.c_str());
            if (temp)
                data.str->assign(temp);
            free_def(temp);
        }
    }

    inline msgpack(const std::wstring&& val) : data() {
        type = MSGPACK_STRING;
        data.str = new std::string;
        if (val.size()) {
            char* temp = utf16_to_utf8(val.c_str());
            if (temp)
                data.str->assign(temp);
            free_def(temp);
        }
    }

    inline ~msgpack() {
        switch (type) {
        case MSGPACK_STRING:
            delete data.str;
            break;
        case MSGPACK_ARRAY:
            delete data.arr;
            break;
        case MSGPACK_MAP:
            delete data.map;
            break;
        }
    }

    inline bool check_null() {
        if (type == MSGPACK_ARRAY)
            return !data.arr->size();
        else if (type == MSGPACK_MAP)
            return !data.map->size();
        return type == MSGPACK_NONE;
    }

    inline bool check_not_null() {
        if (type == MSGPACK_ARRAY)
            return !!data.arr->size();
        else if (type == MSGPACK_MAP)
            return !!data.map->size();
        return type != MSGPACK_NONE;
    }

    inline void clear() {
        switch (type) {
        case MSGPACK_STRING:
            delete data.str;
            break;
        case MSGPACK_ARRAY:
            delete data.arr;
            break;
        case MSGPACK_MAP:
            delete data.map;
            break;
        }
        type = MSGPACK_NONE;
        data = {};
    }
};