DataSaver.h

#pragma once
 
#include <string>
#include <iostream>
#include <typeindex>
 
#include "Strings/ToString.h"
#include "Strings/FromString.h"
 
namespace mvlt
{
    class DataSaver
    {
    private:
        // Void pointer to save pointer to any data
        void* Ptr = nullptr;
 
        // Pointer to data type saver
        std::type_index DataType;
 
        // Pointer to copy function. Required to DataSaver copy
        void (*CopyFunc)(void*& dst, void* src) = nullptr;
 
        // Pointer to delete function. Required to delete pointer since it is not possibly to delete void*
        void (*DeleteFunc)(void*& ptrToDelete) = nullptr;
 
        // A pointer to a function that will convert the value stored inside to a string
        std::string (*ToStringFunc)(void* ptrToPrint) = nullptr;
 
        // Pointer to custom delete function. Required to delete data if it is pointer
        void (*CustomDeleteFunc)(const void* ptr) = nullptr;
 
        // Pointer to function to load data from string to data saver
        bool (*SetDataFromStringFunc)(void* ptrToStoreDataFromString, const std::string& str) = nullptr;
 
    public:
        DataSaver() noexcept;
 
        DataSaver(const DataSaver& other) noexcept;
 
        DataSaver(DataSaver&& other) noexcept = delete;
 
        template <class T>
        explicit DataSaver(const T& data) noexcept : DataType(typeid(void))
        {
            SetData(data);
        }
 
        template <class T, class F>
        DataSaver(const T& data, F&& customDeleteFunc) noexcept : DataType(typeid(void))
        {
            SetData(data, customDeleteFunc);
        }
 
        DataSaver& operator=(const DataSaver& other) noexcept;
 
        DataSaver& operator=(DataSaver&& other) noexcept = delete;
 
        template <class T>
        void SetData(const T& data) noexcept
        {
            SetData(data, nullptr);
        }
 
        bool SetDataFromString(const std::string& data) noexcept;
 
        template <class T, class F>
        void SetData(const T& data, F&& customDeleteFunc) noexcept
        {
            // Clear Ptr if it was data before
            if (Ptr != nullptr)
                DeleteFunc(Ptr);
 
            // Create new T type object and save it pointer like void ptr. Data from data will be copying using copy constructor
            Ptr = static_cast<void*>(new T(data));
 
            // Save data type to DataType
            DataType = typeid(data);
 
            // Set new CopyFunc. It is get to void pointers and convert void pointers to T pointers and copy data.
            CopyFunc = [](void*& dst, void* src)
            {
                // Convert src pointer to T pointer and get data from T pointer.
                // Use T copy constructor to create T object.
                // Allocate new memory to T type and convert it to void pointer.
                dst = static_cast<void*>(new T(*reinterpret_cast<T*>(src)));
            };
 
            // Set new DeleteFunc
            DeleteFunc = [](void*& ptrToDelete)
            {
                delete static_cast<T*>(ptrToDelete);
            };
 
            // Set new to string function
            ToStringFunc = [](void* ptrToPrint)
            {
                return ToString(*static_cast<T*>(ptrToPrint));
            };
 
            // Set custom delete function from dataSaver
            CustomDeleteFunc = customDeleteFunc;
 
            // Set new copy from string function
            SetDataFromStringFunc = [](void* ptrToStoreDataFromString, const std::string& str)
            {
                return FromString(str, *static_cast<T*>(ptrToStoreDataFromString));
            };
        }
 
        template <class T>
        bool GetData(T& data) const noexcept
        {
            // Check data type stored in DataSaver
            if (DataType != typeid(data))
            {
                std::cerr << "Wrong type! Was: " + std::string(DataType.name()) + " Requested: " + typeid(data).name() << "\n";
                return false;
            }
 
            // Check that was data inside Ptr
            if (Ptr == nullptr)
                return false;
 
            // Copy data from Ptr to data
            data = *static_cast<T*>(Ptr);
            return true;
        }
 
        void ResetData() noexcept;
 
        void Swap(DataSaver& other) noexcept;
 
        std::string Str() const noexcept;
 
        std::type_index GetDataType() const noexcept;
 
        ~DataSaver() noexcept;
    };
}