tb_file_utilities.hpp

#ifndef TurtleBrains_FileUtilities_hpp
#define TurtleBrains_FileUtilities_hpp

#include "tb_types.hpp"
#include "tb_defines.hpp"

#include <fstream>

namespace TurtleBrains
{
    namespace Core
    {
        namespace FileUtilities
        {
            //Expects the data to be written in Little-Endian Byte Order.
            void WriteVariableLengthEncoding(tbCore::uint64 length, std::ostream& outputFile);

            //Expects the data to be read in Little-Endian Byte Order.
            tbCore::uint64 ReadVariableLengthEncoding(std::istream& inputFile);

            template<typename Type> Type ReadVariableLength(std::istream& inputFile)
            {
                return tbCore::RangedCast<Type, tbCore::uint64>(ReadVariableLengthEncoding(inputFile));
            }

            //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.

            template <typename Type> void WriteBinary(const Type& object, std::ostream& outputFile)
            {
                outputFile.write(reinterpret_cast<const char*>(&object), sizeof(Type));
            }

            inline void WriteBinary(const tbCore::tbString& object, std::ostream& outputFile)
            {
                const tbCore::uint32 stringLength = object.size();
                WriteVariableLengthEncoding(stringLength, outputFile);
                outputFile.write(object.c_str(), stringLength + 1); //+1 to write the null-terminator.
            }

            template <typename Type> void ReadBinary(Type& object, std::istream& inputFile)
            {
                inputFile.read(reinterpret_cast<char*>(&object), sizeof(Type));
            }

            inline void ReadBinary(tbCore::tbString& object, std::istream& inputFile)
            {
                const tbCore::uint32 stringLength = ReadVariableLength<tbCore::uint32>(inputFile);

                object.clear();

                if (stringLength > 0)
                {
                    object.resize(stringLength); //null-terminator is added already.
                    inputFile.read(&object.at(0), stringLength);
                }

                //We didn't read the null-terminator that was written, I believe the original reason to write the
                //  null-terminator was to be capable of loading into custom strings etc, (doesn't make complete sense
                //  at this point... but, we can't remove it without breaking all previous file formats that ever called
                //  ReadBinary()/WriteBinary() with strings.
                inputFile.seekg(1, std::ios_base::cur);
            }

            template <typename Type> Type ReadBinary(std::istream& inputFile)
            {
                Type object;
                ReadBinary(object, inputFile);
                return object;
            }

            template<> inline tbCore::tbString ReadBinary<tbCore::tbString>(std::istream& inputFile)
            {
                tbCore::tbString object;
                ReadBinary(object, inputFile);
                return object;
            }




        }; /* namespace FileUtilities */
    }; /* namespace Core */
}; /* namespace TurtleBrains */

namespace tbCore = TurtleBrains::Core;

#endif /* TurtleBrains_FileUtilities_hpp */