tb_file_utilities.hpp

 
#ifndef TurtleBrains_FileUtilities_hpp
#define TurtleBrains_FileUtilities_hpp
 
#include <turtle_brains/core/tb_defines.hpp>
#include <turtle_brains/core/tb_types.hpp>
#include <turtle_brains/core/tb_string.hpp>
 
#include <fstream>
#include <vector>
#include <type_traits>
 
namespace TurtleBrains::Core
{
    class DynamicStructure;
};
 
namespace TurtleBrains::Core::FileUtilities
{
    //Expects the data to be written in Little-Endian Byte Order.
    void WriteVariableLengthEncoding(uint64 length, OutputFile& outputFile);
 
    //Expects the data to be read in Little-Endian Byte Order.
    tbCore::uint64 ReadVariableLengthEncoding(InputFile& inputFile);
 
    template<typename Type> Type ReadVariableLength(std::istream& inputFile)
    {
        return tbCore::RangedCast<Type, tbCore::uint64>(ReadVariableLengthEncoding(inputFile));
    }
 
    // Note: For all Binary functions below it is assumed that the file stream was opened in Binary mode. Calling these
    //   on files opened in text mode, which is default, will be likely to cause issues and headaches! You've been warned.
 
    // Note: This is working directly with input/output streams and it might be wise to wrap them with our own
    //   calls to Open() and Close() because this will ensure the file is opened in binary mode and not
    //   accidentally left in text mode. It could also allow TurtleBrains to save a format version itself that
    //   could remove the extra null terminator on the strings now that we have the length saved. Though ideally
    //   this wouldn't add extra information to a file/memory buffer as a developer might feel a little odd with
    //   bytes they didn't put in themselves.
 
    template<typename Type> void WriteBinary(const Type& object, OutputFile& outputFile)
    {   //Until we get a template specialization that ReadBinary(DynamicStructure, inputFile) works as expected,
        //  this will at least point out the errors that would otherwise cause hours of headaches. Either the
        //  DynamicStructure needs to know about FileUtilities or vice-versa, only then can create the specialization.
        // 2025-11-09: This should be pretty impossible to get at this point since we refactored the WriteBinary() and
        //   there is a template specialization for the DynamicStructure. IF we got here, it means someone, somehow,
        //   used a DynamicStructure without properly including tb_dynamic_structure.hpp. That seems impossible.
        tb_static_error_if((std::is_same<Type, DynamicStructure>::value), "This is the wrong WriteBinary, use tbCore::WriteBinary(object, file);");
        outputFile.write(reinterpret_cast<const char*>(&object), sizeof(Type));
    }
 
    template<> void WriteBinary<String>(const String& object, OutputFile& outputFile);
 
    inline void WriteBinary(const void* object, size_t size, OutputFile& outputFile)
    {
        outputFile.write(reinterpret_cast<const char*>(object), size);
    }
 
    template<typename Type> void ReadBinary(Type& object, InputFile& inputFile)
    {
        //Until we get a template specialization that ReadBinary(DynamicStructure, inputFile) works as expected,
        //  this will at least point out the errors that would otherwise cause hours of headaches. Either the
        //  DynamicStructure needs to know about FileUtilities or vice-versa, only then can create the specialization.
        // 2025-11-09: This should be pretty impossible to get at this point since we refactored the ReadBinary() and
        //   there is a template specialization for the DynamicStructure. IF we got here, it means someone, somehow,
        //   used a DynamicStructure without properly including tb_dynamic_structure.hpp. That seems impossible.
        tb_static_error_if((std::is_same<Type, DynamicStructure>::value), "This is the wrong ReadBinary, use object = tbCore::ReadBinary(file);");
        inputFile.read(reinterpret_cast<char*>(&object), sizeof(Type));
    }
 
    template<> void ReadBinary<String>(String& object, InputFile& inputFile);
 
    template<typename Type> Type ReadBinary(InputFile& inputFile)
    {
        Type object;
        ReadBinary(object, inputFile);
        return object;
    }
 
    inline void ReadBinary(void* object, size_t size, InputFile& inputFile)
    {
        inputFile.read(reinterpret_cast<char*>(object), size);
    }
 
    std::vector<tbCore::byte> LoadBinaryFileContents(const String& filePath);
 
    String LoadFileContentsToString(const String& filePath, bool trimTrailingWhitespace = false);
    bool SaveStringContentsToFile(const String& filePath, const String& stringContents);
 
    tbCore::uint32 ComputeCRC32(const String& filePath, tbCore::uint32 crc32 = 0);
 
    tbCore::uint32 ComputeCRC32(const std::vector<tbCore::byte>& data, tbCore::uint32 crc32 = 0);
 
}; /* namespace TurtleBrains::Core::FileUtilities */
 
namespace tbCore = TurtleBrains::Core;
 
#endif /* TurtleBrains_FileUtilities_hpp */