StreamReader.h

#pragma once
 
#include "LkEngine/Core/Core.h"
#include "LkEngine/Core/Memory/Buffer.h"
 
//#include <filesystem> /// REMOVE
 
 
namespace LkEngine {
 
    class StreamReader
    {
    public:
        virtual ~StreamReader() = default;
 
        virtual bool IsStreamGood() const = 0;
        virtual uint64_t GetStreamPosition() = 0;
        virtual void SetStreamPosition(uint64_t position) = 0;
        virtual bool ReadData(char* destination, size_t size) = 0;
 
        void ReadBuffer(FBuffer& Buffer, uint32_t size = 0);
        void ReadString(std::string& string);
 
        operator bool() const { return IsStreamGood(); }
 
        template<typename T>
        void ReadRaw(T& type)
        {
            bool success = ReadData((char*)&type, sizeof(T));
            LK_ASSERT(success);
        }
 
        template<typename T>
        void ReadObject(T& obj)
        {
            T::Deserialize(this, obj);
        }
 
        template<typename Key, typename Value>
        void ReadMap(std::map<Key, Value>& map, uint32_t size = 0)
        {
            if (size == 0)
            {
                ReadRaw<uint32_t>(size);
            }
 
            for (uint32_t i = 0; i < size; i++)
            {
                Key key;
                if constexpr (std::is_trivial<Key>())
                {
                    ReadRaw<Key>(key);
                }
                else
                {
                    ReadObject<Key>(key);
                }
 
                if constexpr (std::is_trivial<Value>())
                {
                    ReadRaw<Value>(map[key]);
                }
                else
                {
                    ReadObject<Value>(map[key]);
                }
            }
        }
 
        template<typename Key, typename Value>
        void ReadMap(std::unordered_map<Key, Value>& map, uint32_t size = 0)
        {
            if (size == 0)
                ReadRaw<uint32_t>(size);
 
            for (uint32_t i = 0; i < size; i++)
            {
                Key key;
                if constexpr (std::is_trivial<Key>())
                    ReadRaw<Key>(key);
                else
                    ReadObject<Key>(key);
 
                if constexpr (std::is_trivial<Value>())
                    ReadRaw<Value>(map[key]);
                else
                    ReadObject<Value>(map[key]);
            }
        }
 
        template<typename Value>
        void ReadMap(std::unordered_map<std::string, Value>& map, uint32_t size = 0)
        {
            if (size == 0)
                ReadRaw<uint32_t>(size);
 
            for (uint32_t i = 0; i < size; i++)
            {
                std::string key;
                ReadString(key);
 
                if constexpr (std::is_trivial<Value>())
                    ReadRaw<Value>(map[key]);
                else
                    ReadObject<Value>(map[key]);
            }
        }
 
        template<typename T>
        void ReadArray(std::vector<T>& array, uint32_t size = 0)
        {
            if (size == 0)
                ReadRaw<uint32_t>(size);
 
            array.resize(size);
 
            for (uint32_t i = 0; i < size; i++)
            {
                if constexpr (std::is_trivial<T>())
                    ReadRaw<T>(array[i]);
                else
                    ReadObject<T>(array[i]);
            }
        }
 
    };
 
    template<>
    inline void StreamReader::ReadArray(std::vector<std::string>& array, uint32_t size)
    {
        if (size == 0)
            ReadRaw<uint32_t>(size);
 
        array.resize(size);
 
        for (uint32_t i = 0; i < size; i++)
            ReadString(array[i]);
    }
 
}