Serializer.h

Go to the documentation of this file.

#ifndef DENGINE_SERIALIZER_H
#define DENGINE_SERIALIZER_H

#include <iostream>
#include <fstream>
#include <vector>
#include <cstring>
#include "NanoLog.h"

namespace dengine {
    template<typename T>
    class Serializer {
    public:
        Serializer(std::string filePath);

        bool saveToFile(const T* obj);
        T loadFromFile();
    private:
        std::string path;
        std::vector<char> serializeObject(const T* obj);
        bool saveSerializedObject(const std::vector<char>& serializedData);
        std::vector<char> loadSerializedData();

        T deserializeData(const std::vector<char>& data);
    };


    template<typename T>
    Serializer<T>::Serializer(std::string filePath){
        path = filePath;
    }

    template<typename T>
    bool Serializer<T>::saveToFile(const T* obj){
        std::vector<char> objData = serializeObject(obj);
        return saveSerializedObject(objData);
    }

    template<typename T>
    T Serializer<T>::loadFromFile(){
        std::vector<char> objData = loadSerializedData();
        return deserializeData(objData);
    }

    template <typename T>
    std::vector<char> Serializer<T>::serializeObject(const T* obj) {
        std::vector<char> buffer;
        buffer.resize(sizeof(*obj));
        std::memcpy(buffer.data(), obj, sizeof(*obj));
        return buffer;
    }

    template<typename T>
    bool Serializer<T>::saveSerializedObject(const std::vector<char>& serializedData) {
        std::ofstream file(path, std::ios::binary);
        if (!file) {
            LOG_CRIT << "Failed to open file: " << path;
            return false;
        }

        // Save serialized object to file
        file.write(serializedData.data(), serializedData.size());
        if (!file) {
            LOG_CRIT << "Failed to write to file: " << path;
            return false;
        }

        LOG_INFO << "Serialized object saved to file: " << path;
        return true;
    }

    template <typename T>
    T Serializer<T>::deserializeData(const std::vector<char>& data) {
        T obj;
        std::memcpy(&obj, data.data(), sizeof(obj));
        return obj;
    }

    template <typename T>
    std::vector<char> Serializer<T>::loadSerializedData() {
        std::ifstream file(path, std::ios::binary | std::ios::ate);
        if (!file) {
            std::cerr << "Failed to open file: " << path << std::endl;
            return {};
        }

        std::streamsize fileSize = file.tellg();
        file.seekg(0, std::ios::beg);

        std::vector<char> buffer(fileSize);
        file.read(buffer.data(), fileSize);
        if (!file) {
            std::cerr << "Failed to read file: " << path << std::endl;
            return {};
        }

        return buffer;
    }

}



#endif //DENGINE_SERIALIZER_H