mde_serialization.hpp

Go to the documentation of this file.

 
#ifndef MDE_SERIALIZATION_H
#define MDE_SERIALIZATION_H
 
#include "mde_common.hpp"
#include <fstream>
#include <nlohmann/json.hpp>
 
namespace mde {
 
namespace slz {
 
using JSON = nlohmann::json;
 
template<typename T>
struct ValueSerializer {
    JSON save(const T &val);
    T load(const JSON &j);
};
 
 
template<typename T>
struct DefaultValueSerializer : ValueSerializer<T> {
    JSON save(const T &val) {
        return JSON(val);
    }
 
    T load(const JSON &j) {
        return j.get<T>();
    }
};
 
struct SerializationError : public std::invalid_argument {
    SerializationError(const String &message):
        std::invalid_argument(message.c_str()) {}
};
 
template<typename MapT>
JSON binary_operation_map_to_json(const MapT &map) {
    JSON ret = JSON::array();
    for (auto &i : map) {
        ret.push_back(JSON::array({JSON::array({i.first.left, i.first.right}), i.second}));
    }
    return ret;
}
 
template<typename MapT>
void binary_operation_map_from_json(MapT &map, const JSON &obj) {
    map.clear();
 
    if (!obj.is_array()) {
        throw SerializationError("Expected array (root)");
    }
 
    for (auto &tuple : obj) {
        if (!tuple.is_array() || !(tuple.size() == 2)) {
            throw SerializationError("Expected array of size 2 (root[*])");
        } else if (!tuple[0].is_array() || !(tuple[0].size() == 2)) {
            throw SerializationError("Expected array of size 2 (root[*][0])");
        } else if (!tuple[0][0].is_number_integer() || !tuple[0][1].is_number_integer()) {
            throw SerializationError("Expected array of size 2 (root[*][0][0,1])");
        } else if (!tuple[1].is_number_integer()) {
            throw SerializationError("Expected array of size 2 (root[*][1])");
        }
        map.insert({{tuple[0][0], tuple[0][1]}, tuple[1]});
    }
}
 
template<typename MapT>
JSON unary_operation_map_to_json(const MapT &map) {
    JSON ret = JSON::array();
    for (auto &i : map) {
        JSON::array({i.first, i.second});
    }
    return ret;
}
 
template<typename MapT>
void unary_operation_map_from_json(MapT &map, const JSON &obj) {
    map.clear();
 
    if (!obj.is_array()) {
        throw SerializationError("Expected array (root)");
    }
 
    for (auto &tuple : obj) {
        if (!tuple.is_array() || !(tuple.size() == 2)) {
            throw SerializationError("Expected array of size 2 (root[*])");
        } else if (!tuple[0].is_number_integer() || !tuple[1].is_number_integer()) {
            throw SerializationError("Expected array of size 2 (root[*][0,1])");
        }
        map.insert({tuple[0], tuple[1]});
    }
}
 
template<typename StoreT, typename Serializer>
JSON storage_array_to_json(const StoreT &store, Serializer &serializer) {
    JSON ret = JSON::array();
    for (Size set_index = 0; set_index < store.size(); set_index++) {
        JSON set_arr = JSON::array();
        for (auto &elem : *store.at(set_index).get()) {
            set_arr.push_back(serializer.save(elem.get_key()));
        }
        ret.push_back(set_arr);
    }
    return ret;
}
 
template<typename MDET, typename Serializer>
void register_storage_from_json(MDET &mde, const JSON &obj, Serializer &serializer) {
 
    using PropertyElement = typename MDET::PropertyElement;
 
    if (!obj.is_array()) {
        throw SerializationError("Expected array (root)");
    }
 
    for (Size set_index = 0; set_index < obj.size(); set_index++) {
        Vector<PropertyElement> data;
        if (!obj[set_index].is_array()) {
            throw SerializationError("Expected array (root[*])");
        }
        for (auto &i : obj[set_index]) {
            data.push_back(PropertyElement(serializer.load(i)));
        }
        mde.register_set(std::move(data));
    }
}
 
template<typename Serializer, typename StoreT>
JSON storage_array_to_json_nested(const StoreT &store, Serializer &serializer) {
    JSON ret = JSON::array();
 
    for (Size set_index = 0; set_index < store.size(); set_index++) {
        JSON set_arr = JSON::array();
 
        for (auto &elem : *store.at(set_index).get()) {
            JSON child_arr = JSON::array();
 
            std::apply([&child_arr](const auto&... args) {
                (child_arr.push_back(args.value), ...);
            }, elem.get_value());
 
            set_arr.push_back(
                JSON::array({
                    serializer.save(elem.get_key()),
                    child_arr
                })
            );
        }
        ret.push_back(set_arr);
    }
    return ret;
}
 
template <typename Tuple, std::size_t... Is>
Tuple json_list_to_tuple_internal(const JSON& l, std::index_sequence<Is...>) {
    return Tuple{ (l[Is].template get<size_t>())... };
}
 
template <typename Tuple>
Tuple json_list_to_tuple(const JSON& l) {
    constexpr std::size_t N = std::tuple_size_v<Tuple>;
    return json_list_to_tuple_internal<Tuple>(l, std::make_index_sequence<N>{});
}
 
template<typename Serializer, typename MDET>
void register_storage_from_json_nested(MDET &mde, const JSON &obj, Serializer &serializer) {
 
    using PropertyElement = typename MDET::PropertyElement;
    using ChildValueList = typename MDET::Nesting::ChildValueList;
    constexpr const Size num_children = MDET::Nesting::num_children;
 
    if (!obj.is_array()) {
        throw SerializationError("Expected array (root)");
    }
 
    for (Size set_index = 0; set_index < obj.size(); set_index++) {
        Vector<PropertyElement> data;
        if (!obj[set_index].is_array()) {
            throw SerializationError("Expected array (root[*])");
        }
        for (auto &i : obj[set_index]) {
            if (i.size() != 2) {
                throw SerializationError("Expected array of size 2 (root[*][*])");
            } else if (!i[1].is_array() || i[1].size() != num_children) {
                throw SerializationError(
                    "Expected array of size " + std::to_string(num_children) +
                    " (root[*][1])");
            }
            auto cvl = json_list_to_tuple<ChildValueList>(i[1]);
            data.push_back(PropertyElement(serializer.load(i[0]), cvl));
        }
        mde.register_set(std::move(data));
    }
}
 
template<typename MDET>
void mde_to_json_internal(
    MDET &root, JSON &obj,
    HashSet<void *> &visited, String &path) {
 
    if (visited.count(&root) > 0) {
        // MDE_DEBUG(std::cout << "Already found '" << root.name << "' <" << &root << ">\n";);
        // MDE_DEBUG(std::cout << "Path: " << path << "\n";);
        return;
    } else {
        // MDE_DEBUG(std::cout << "Visited '" << root.name << "' <" << &root << ">\n";);
        // MDE_DEBUG(std::cout << "Path: " << path << "\n";);
        visited.insert(&root);
    }
 
    obj[path] = root.to_json();
 
    std::apply([&](auto&... child_refs) {
        // Local counter for this node's children
        [[maybe_unused]] Size i = 0;
 
        // The fold expression calls this lambda for EACH child in the pack
        ([&](auto& child) {
            String current_path = path + std::to_string(i++) + "/";
            mde_to_json_internal(child, obj, visited, current_path);
        }(child_refs), ...);
    }, root.get_reflist());
}
 
template<typename MDET>
JSON mde_to_json(MDET &root) {
    HashSet<void *> visited = {};
    String path = "/";
    JSON obj = JSON::object();
    obj["mde_version"] = MDE_VERSION_STRING;
    mde_to_json_internal(root, obj, visited, path);
 
    return obj;
}
 
template<typename MDET>
void mde_from_json_internal(
    MDET &root, const JSON &obj,
    HashSet<void *> &visited, String &path) {
 
    if (visited.count(&root) > 0) {
        // MDE_DEBUG(std::cout << "Already found '" << root.name << "' <" << &root << ">\n";);
        // MDE_DEBUG(std::cout << "Path: " << path << "\n";);
        return;
    } else {
        // MDE_DEBUG(std::cout << "Visited '" << root.name << "' <" << &root << ">\n";);
        // MDE_DEBUG(std::cout << "Path: " << path << "\n";);
        visited.insert(&root);
    }
 
    root.load_from_json(obj[path]);
 
    std::apply([&](auto&... child_refs) {
        // Local counter for this node's children
        [[maybe_unused]] Size i = 0;
 
        // The fold expression calls this lambda for EACH child in the pack
        ([&](auto& child) {
            String current_path = path + std::to_string(i++) + "/";
            mde_from_json_internal(child, obj, visited, current_path);
        }(child_refs), ...);
    }, root.get_reflist());
}
 
template<typename MDET>
void mde_from_json(MDET &root, const JSON &obj) {
    HashSet<void *> visited = {};
    String path = "/";
    mde_from_json_internal(root, obj, visited, path);
}
 
inline String json_to_string(const JSON &obj) {
    return obj.dump();
}
 
inline Vector<uint8_t> json_to_bson(const JSON &obj) {
    return JSON::to_bson(obj);
}
 
inline bool json_to_file(const JSON &obj, const String &file_path) {
    std::ofstream f(file_path);
 
    if (!f.is_open()) {
        return false;
    }
 
    f << obj;
    return true;
}
 
inline bool json_to_file_bson(const JSON &obj, const String &file_path) {
    std::ofstream f(file_path, std::ios::out | std::ios::binary);
 
    if (!f.is_open()) {
        return false;
    }
 
    Vector<uint8_t> data = json_to_bson(obj);
    f.write(reinterpret_cast<const char *>(data.data()), data.size());
    return true;
}
 
inline JSON load_json_file(const String &file_path) {
    std::ifstream f(file_path);
 
    if (!f.is_open()) {
        throw SerializationError("Could not open '" + file_path + "'");
    }
 
    return JSON::parse(f);
}
 
inline JSON load_bson_file(const String &file_path) {
    std::ifstream f(file_path);
 
    if (!f.is_open()) {
        throw SerializationError("Could not open '" + file_path + "'");
    }
 
    return JSON::from_bson(f);
}
 
template<typename MDET>
bool save(const MDET &mde, const String &file_path) {
    return json_to_file(mde_to_json(mde), file_path);
}
 
template<typename MDET>
bool save_bson(const MDET &mde, const String &file_path) {
    return json_to_file_bson(mde_to_json(mde), file_path);
}
 
template<typename MDET>
void load(MDET &mde, const String &file_path) {
    mde_from_json(mde, load_json_file(file_path));
}
 
template<typename MDET>
void load_bson(MDET &mde, const String &file_path) {
    mde_from_json(mde, load_bson_file(file_path));
}
 
}; // END namespace slz
 
}; // END namespace mde
 
#endif