archive/Cemu
1
0
Fork 0
mirror of https://github.com/cemu-project/Cemu.git synced 2025-07-13 02:08:31 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

FileStream: Change indent to tabs.

Browse source
This commit is contained in:
goeiecool9999 2022-09-07 00:54:58 +02:00 • committed by klaas
parent 1520cee91c
commit 6c89de506b
2 changed files with 261 additions and 261 deletions
Download patch file Download diff file Expand all files Collapse all files

388
src/Common/filestream.cpp
View file

@ -5,188 +5,188 @@
FileStream* FileStream::openFile(std::string_view path) FileStream* FileStream::openFile(std::string_view path)
{ {
HANDLE hFile = CreateFileW(boost::nowide::widen(path.data(), path.size()).c_str(), FILE_GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0); HANDLE hFile = CreateFileW(boost::nowide::widen(path.data(), path.size()).c_str(), FILE_GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
if (hFile == INVALID_HANDLE_VALUE) if (hFile == INVALID_HANDLE_VALUE)
return nullptr; return nullptr;
return new FileStream(hFile); return new FileStream(hFile);
} }
FileStream* FileStream::openFile(const wchar_t* path, bool allowWrite = false) FileStream* FileStream::openFile(const wchar_t* path, bool allowWrite = false)
{ {
HANDLE hFile = CreateFileW(path, allowWrite ? (FILE_GENERIC_READ | FILE_GENERIC_WRITE) : FILE_GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0); HANDLE hFile = CreateFileW(path, allowWrite ? (FILE_GENERIC_READ | FILE_GENERIC_WRITE) : FILE_GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
if (hFile == INVALID_HANDLE_VALUE) if (hFile == INVALID_HANDLE_VALUE)
return nullptr; return nullptr;
return new FileStream(hFile); return new FileStream(hFile);
} }
FileStream* FileStream::openFile2(const fs::path& path, bool allowWrite = false) FileStream* FileStream::openFile2(const fs::path& path, bool allowWrite = false)
{ {
return openFile(path.generic_wstring().c_str(), allowWrite); return openFile(path.generic_wstring().c_str(), allowWrite);
} }
FileStream* FileStream::createFile(const wchar_t* path) FileStream* FileStream::createFile(const wchar_t* path)
{ {
HANDLE hFile = CreateFileW(path, FILE_GENERIC_READ | FILE_GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0); HANDLE hFile = CreateFileW(path, FILE_GENERIC_READ | FILE_GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0);
if (hFile == INVALID_HANDLE_VALUE) if (hFile == INVALID_HANDLE_VALUE)
return nullptr; return nullptr;
return new FileStream(hFile); return new FileStream(hFile);
} }
FileStream* FileStream::createFile(std::string_view path) FileStream* FileStream::createFile(std::string_view path)
{ {
auto w = boost::nowide::widen(path.data(), path.size()); auto w = boost::nowide::widen(path.data(), path.size());
HANDLE hFile = CreateFileW(w.c_str(), FILE_GENERIC_READ | FILE_GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0); HANDLE hFile = CreateFileW(w.c_str(), FILE_GENERIC_READ | FILE_GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, 0, 0);
if (hFile == INVALID_HANDLE_VALUE) if (hFile == INVALID_HANDLE_VALUE)
return nullptr; return nullptr;
return new FileStream(hFile); return new FileStream(hFile);
} }
FileStream* FileStream::createFile2(const fs::path& path) FileStream* FileStream::createFile2(const fs::path& path)
{ {
return createFile(path.generic_wstring().c_str()); return createFile(path.generic_wstring().c_str());
} }
std::optional<std::vector<uint8>> FileStream::LoadIntoMemory(const fs::path& path) std::optional<std::vector<uint8>> FileStream::LoadIntoMemory(const fs::path& path)
{ {
FileStream* fs = openFile2(path); FileStream* fs = openFile2(path);
if (!fs) if (!fs)
return std::nullopt; return std::nullopt;
uint64 fileSize = fs->GetSize(); uint64 fileSize = fs->GetSize();
if(fileSize > 0xFFFFFFFFull) if(fileSize > 0xFFFFFFFFull)
{ {
delete fs; delete fs;
return std::nullopt; return std::nullopt;
} }
std::optional<std::vector<uint8>> v(fileSize); std::optional<std::vector<uint8>> v(fileSize);
if (fs->readData(v->data(), (uint32)fileSize) != (uint32)fileSize) if (fs->readData(v->data(), (uint32)fileSize) != (uint32)fileSize)
{ {
delete fs; delete fs;
return std::nullopt; return std::nullopt;
} }
delete fs; delete fs;
return v; return v;
} }
void FileStream::SetPosition(uint64 pos) void FileStream::SetPosition(uint64 pos)
{ {
LONG posHigh = (LONG)(pos >> 32); LONG posHigh = (LONG)(pos >> 32);
LONG posLow = (LONG)(pos); LONG posLow = (LONG)(pos);
SetFilePointer(m_hFile, posLow, &posHigh, FILE_BEGIN); SetFilePointer(m_hFile, posLow, &posHigh, FILE_BEGIN);
} }
uint64 FileStream::GetSize() uint64 FileStream::GetSize()
{ {
DWORD fileSizeHigh = 0; DWORD fileSizeHigh = 0;
DWORD fileSizeLow = 0; DWORD fileSizeLow = 0;
fileSizeLow = GetFileSize(m_hFile, &fileSizeHigh); fileSizeLow = GetFileSize(m_hFile, &fileSizeHigh);
return ((uint64)fileSizeHigh << 32) | (uint64)fileSizeLow; return ((uint64)fileSizeHigh << 32) | (uint64)fileSizeLow;
} }
bool FileStream::SetEndOfFile() bool FileStream::SetEndOfFile()
{ {
return ::SetEndOfFile(m_hFile) != 0; return ::SetEndOfFile(m_hFile) != 0;
} }
void FileStream::extract(std::vector<uint8>& data) void FileStream::extract(std::vector<uint8>& data)
{ {
DWORD fileSize = GetFileSize(m_hFile, nullptr); DWORD fileSize = GetFileSize(m_hFile, nullptr);
data.resize(fileSize); data.resize(fileSize);
SetFilePointer(m_hFile, 0, 0, FILE_BEGIN); SetFilePointer(m_hFile, 0, 0, FILE_BEGIN);
DWORD bt; DWORD bt;
ReadFile(m_hFile, data.data(), fileSize, &bt, nullptr); ReadFile(m_hFile, data.data(), fileSize, &bt, nullptr);
} }
uint32 FileStream::readData(void* data, uint32 length) uint32 FileStream::readData(void* data, uint32 length)
{ {
DWORD bytesRead = 0; DWORD bytesRead = 0;
ReadFile(m_hFile, data, length, &bytesRead, NULL); ReadFile(m_hFile, data, length, &bytesRead, NULL);
return bytesRead; return bytesRead;
} }
bool FileStream::readU64(uint64& v) bool FileStream::readU64(uint64& v)
{ {
return readData(&v, sizeof(uint64)) == sizeof(uint64); return readData(&v, sizeof(uint64)) == sizeof(uint64);
} }
bool FileStream::readU32(uint32& v) bool FileStream::readU32(uint32& v)
{ {
return readData(&v, sizeof(uint32)) == sizeof(uint32); return readData(&v, sizeof(uint32)) == sizeof(uint32);
} }
bool FileStream::readU8(uint8& v) bool FileStream::readU8(uint8& v)
{ {
return readData(&v, sizeof(uint8)) == sizeof(uint8); return readData(&v, sizeof(uint8)) == sizeof(uint8);
} }
bool FileStream::readLine(std::string& line) bool FileStream::readLine(std::string& line)
{ {
line.clear(); line.clear();
uint8 c; uint8 c;
bool isEOF = true; bool isEOF = true;
while (readU8(c)) while (readU8(c))
{ {
isEOF = false; isEOF = false;
if(c == '\r') if(c == '\r')
continue; continue;
if (c == '\n') if (c == '\n')
break; break;
line.push_back((char)c); line.push_back((char)c);
} }
return !isEOF; return !isEOF;
} }
sint32 FileStream::writeData(const void* data, sint32 length) sint32 FileStream::writeData(const void* data, sint32 length)
{ {
DWORD bytesWritten = 0; DWORD bytesWritten = 0;
WriteFile(m_hFile, data, length, &bytesWritten, NULL); WriteFile(m_hFile, data, length, &bytesWritten, NULL);
return bytesWritten; return bytesWritten;
} }
void FileStream::writeU64(uint64 v) void FileStream::writeU64(uint64 v)
{ {
writeData(&v, sizeof(uint64)); writeData(&v, sizeof(uint64));
} }
void FileStream::writeU32(uint32 v) void FileStream::writeU32(uint32 v)
{ {
writeData(&v, sizeof(uint32)); writeData(&v, sizeof(uint32));
} }
void FileStream::writeU8(uint8 v) void FileStream::writeU8(uint8 v)
{ {
writeData(&v, sizeof(uint8)); writeData(&v, sizeof(uint8));
} }
void FileStream::writeStringFmt(const char* format, ...) void FileStream::writeStringFmt(const char* format, ...)
{ {
char buffer[2048]; char buffer[2048];
va_list args; va_list args;
va_start(args, format); va_start(args, format);
vsnprintf(buffer, sizeof(buffer), format, args); vsnprintf(buffer, sizeof(buffer), format, args);
writeData(buffer, (sint32)strlen(buffer)); writeData(buffer, (sint32)strlen(buffer));
} }
void FileStream::writeString(const char* str) void FileStream::writeString(const char* str)
{ {
writeData(str, (sint32)strlen(str)); writeData(str, (sint32)strlen(str));
} }
void FileStream::writeLine(const char* str) void FileStream::writeLine(const char* str)
{ {
writeData(str, (sint32)strlen(str)); writeData(str, (sint32)strlen(str));
writeData("\r\n", 2); writeData("\r\n", 2);
} }
FileStream::~FileStream() FileStream::~FileStream()
{ {
if(m_isValid) if(m_isValid)
CloseHandle(m_hFile); CloseHandle(m_hFile);
} }
FileStream::FileStream(HANDLE hFile) FileStream::FileStream(HANDLE hFile)
{ {
m_hFile = hFile; m_hFile = hFile;
m_isValid = true; m_isValid = true;
} }
@ -196,215 +196,215 @@ FileStream::FileStream(HANDLE hFile)
FileStream* FileStream::openFile(std::string_view path) FileStream* FileStream::openFile(std::string_view path)
{ {
return openFile2(path, false); return openFile2(path, false);
} }
FileStream* FileStream::openFile(const wchar_t* path, bool allowWrite) FileStream* FileStream::openFile(const wchar_t* path, bool allowWrite)
{ {
return openFile2(path, allowWrite); return openFile2(path, allowWrite);
} }
FileStream* FileStream::openFile2(const fs::path& path, bool allowWrite) FileStream* FileStream::openFile2(const fs::path& path, bool allowWrite)
{ {
//return openFile(path.generic_wstring().c_str(), allowWrite); //return openFile(path.generic_wstring().c_str(), allowWrite);
FileStream* fs = new FileStream(path, true, allowWrite); FileStream* fs = new FileStream(path, true, allowWrite);
if (fs->m_isValid) if (fs->m_isValid)
return fs; return fs;
delete fs; delete fs;
return nullptr; return nullptr;
} }
FileStream* FileStream::createFile(const wchar_t* path) FileStream* FileStream::createFile(const wchar_t* path)
{ {
return createFile2(path); return createFile2(path);
} }
FileStream* FileStream::createFile(std::string_view path) FileStream* FileStream::createFile(std::string_view path)
{ {
return createFile2(path); return createFile2(path);
} }
FileStream* FileStream::createFile2(const fs::path& path) FileStream* FileStream::createFile2(const fs::path& path)
{ {
FileStream* fs = new FileStream(path, false, false); FileStream* fs = new FileStream(path, false, false);
if (fs->m_isValid) if (fs->m_isValid)
return fs; return fs;
delete fs; delete fs;
return nullptr; return nullptr;
} }
std::optional<std::vector<uint8>> FileStream::LoadIntoMemory(const fs::path& path) std::optional<std::vector<uint8>> FileStream::LoadIntoMemory(const fs::path& path)
{ {
FileStream* fs = openFile2(path); FileStream* fs = openFile2(path);
if (!fs) if (!fs)
return std::nullopt; return std::nullopt;
uint64 fileSize = fs->GetSize(); uint64 fileSize = fs->GetSize();
if (fileSize > 0xFFFFFFFFull) if (fileSize > 0xFFFFFFFFull)
{ {
delete fs; delete fs;
return std::nullopt; return std::nullopt;
} }
std::optional<std::vector<uint8>> v(fileSize); std::optional<std::vector<uint8>> v(fileSize);
if (fs->readData(v->data(), (uint32)fileSize) != (uint32)fileSize) if (fs->readData(v->data(), (uint32)fileSize) != (uint32)fileSize)
{ {
delete fs; delete fs;
return std::nullopt; return std::nullopt;
} }
delete fs; delete fs;
return v; return v;
} }
void FileStream::SetPosition(uint64 pos) void FileStream::SetPosition(uint64 pos)
{ {
cemu_assert(m_isValid); cemu_assert(m_isValid);
if (m_prevOperationWasWrite) if (m_prevOperationWasWrite)
m_fileStream.seekp((std::streampos)pos); m_fileStream.seekp((std::streampos)pos);
else else
m_fileStream.seekg((std::streampos)pos); m_fileStream.seekg((std::streampos)pos);
} }
uint64 FileStream::GetSize() uint64 FileStream::GetSize()
{ {
cemu_assert(m_isValid); cemu_assert(m_isValid);
auto currentPos = m_fileStream.tellg(); auto currentPos = m_fileStream.tellg();
m_fileStream.seekg(0, std::ios::end); m_fileStream.seekg(0, std::ios::end);
auto fileSize = m_fileStream.tellg(); auto fileSize = m_fileStream.tellg();
m_fileStream.seekg(currentPos, std::ios::beg); m_fileStream.seekg(currentPos, std::ios::beg);
uint64 fs = (uint64)fileSize; uint64 fs = (uint64)fileSize;
return fs; return fs;
} }
bool FileStream::SetEndOfFile() bool FileStream::SetEndOfFile()
{ {
assert_dbg(); assert_dbg();
return true; return true;
//return ::SetEndOfFile(m_hFile) != 0; //return ::SetEndOfFile(m_hFile) != 0;
} }
void FileStream::extract(std::vector<uint8>& data) void FileStream::extract(std::vector<uint8>& data)
{ {
uint64 fileSize = GetSize(); uint64 fileSize = GetSize();
SetPosition(0); SetPosition(0);
data.resize(fileSize); data.resize(fileSize);
readData(data.data(), fileSize); readData(data.data(), fileSize);
} }
uint32 FileStream::readData(void* data, uint32 length) uint32 FileStream::readData(void* data, uint32 length)
{ {
SyncReadWriteSeek(false); SyncReadWriteSeek(false);
m_fileStream.read((char*)data, length); m_fileStream.read((char*)data, length);
size_t bytesRead = m_fileStream.gcount(); size_t bytesRead = m_fileStream.gcount();
return (uint32)bytesRead; return (uint32)bytesRead;
} }
bool FileStream::readU64(uint64& v) bool FileStream::readU64(uint64& v)
{ {
return readData(&v, sizeof(uint64)) == sizeof(uint64); return readData(&v, sizeof(uint64)) == sizeof(uint64);
} }
bool FileStream::readU32(uint32& v) bool FileStream::readU32(uint32& v)
{ {
return readData(&v, sizeof(uint32)) == sizeof(uint32); return readData(&v, sizeof(uint32)) == sizeof(uint32);
} }
bool FileStream::readU8(uint8& v) bool FileStream::readU8(uint8& v)
{ {
return readData(&v, sizeof(uint8)) == sizeof(uint8); return readData(&v, sizeof(uint8)) == sizeof(uint8);
} }
bool FileStream::readLine(std::string& line) bool FileStream::readLine(std::string& line)
{ {
line.clear(); line.clear();
uint8 c; uint8 c;
bool isEOF = true; bool isEOF = true;
while (readU8(c)) while (readU8(c))
{ {
isEOF = false; isEOF = false;
if (c == '\r') if (c == '\r')
continue; continue;
if (c == '\n') if (c == '\n')
break; break;
line.push_back((char)c); line.push_back((char)c);
} }
return !isEOF; return !isEOF;
} }
sint32 FileStream::writeData(const void* data, sint32 length) sint32 FileStream::writeData(const void* data, sint32 length)
{ {
SyncReadWriteSeek(true); SyncReadWriteSeek(true);
m_fileStream.write((const char*)data, length); m_fileStream.write((const char*)data, length);
return length; return length;
} }
void FileStream::writeU64(uint64 v) void FileStream::writeU64(uint64 v)
{ {
writeData(&v, sizeof(uint64)); writeData(&v, sizeof(uint64));
} }
void FileStream::writeU32(uint32 v) void FileStream::writeU32(uint32 v)
{ {
writeData(&v, sizeof(uint32)); writeData(&v, sizeof(uint32));
} }
void FileStream::writeU8(uint8 v) void FileStream::writeU8(uint8 v)
{ {
writeData(&v, sizeof(uint8)); writeData(&v, sizeof(uint8));
} }
void FileStream::writeStringFmt(const char* format, ...) void FileStream::writeStringFmt(const char* format, ...)
{ {
char buffer[2048]; char buffer[2048];
va_list args; va_list args;
va_start(args, format); va_start(args, format);
vsnprintf(buffer, sizeof(buffer), format, args); vsnprintf(buffer, sizeof(buffer), format, args);
writeData(buffer, (sint32)strlen(buffer)); writeData(buffer, (sint32)strlen(buffer));
} }
void FileStream::writeString(const char* str) void FileStream::writeString(const char* str)
{ {
writeData(str, (sint32)strlen(str)); writeData(str, (sint32)strlen(str));
} }
void FileStream::writeLine(const char* str) void FileStream::writeLine(const char* str)
{ {
writeData(str, (sint32)strlen(str)); writeData(str, (sint32)strlen(str));
writeData("\r\n", 2); writeData("\r\n", 2);
} }
FileStream::~FileStream() FileStream::~FileStream()
{ {
if (m_isValid) if (m_isValid)
{ {
m_fileStream.close(); m_fileStream.close();
} }
// CloseHandle(m_hFile); // CloseHandle(m_hFile);
} }
FileStream::FileStream(const fs::path& path, bool isOpen, bool isWriteable) FileStream::FileStream(const fs::path& path, bool isOpen, bool isWriteable)
{ {
if (isOpen) if (isOpen)
{ {
m_fileStream.open(path, isWriteable ? (std::ios_base::in | std::ios_base::out | std::ios_base::binary) : (std::ios_base::in | std::ios_base::binary)); m_fileStream.open(path, isWriteable ? (std::ios_base::in | std::ios_base::out | std::ios_base::binary) : (std::ios_base::in | std::ios_base::binary));
m_isValid = m_fileStream.is_open(); m_isValid = m_fileStream.is_open();
} }
else else
{ {
m_fileStream.open(path, std::ios_base::in | std::ios_base::out | std::ios_base::binary | std::ios_base::trunc); m_fileStream.open(path, std::ios_base::in | std::ios_base::out | std::ios_base::binary | std::ios_base::trunc);
m_isValid = m_fileStream.is_open(); m_isValid = m_fileStream.is_open();
} }
} }
void FileStream::SyncReadWriteSeek(bool nextOpIsWrite) void FileStream::SyncReadWriteSeek(bool nextOpIsWrite)
{ {
// nextOpIsWrite == false -> read. Otherwise write // nextOpIsWrite == false -> read. Otherwise write
if (nextOpIsWrite == m_prevOperationWasWrite) if (nextOpIsWrite == m_prevOperationWasWrite)
return; return;
if (nextOpIsWrite) if (nextOpIsWrite)
m_fileStream.seekp(m_fileStream.tellg(), std::ios::beg); m_fileStream.seekp(m_fileStream.tellg(), std::ios::beg);
else else
m_fileStream.seekg(m_fileStream.tellp(), std::ios::beg); m_fileStream.seekg(m_fileStream.tellp(), std::ios::beg);
m_prevOperationWasWrite = nextOpIsWrite; m_prevOperationWasWrite = nextOpIsWrite;
} }
#endif #endif

134
src/Common/filestream.h
View file

@ -6,52 +6,52 @@
class FileStream class FileStream
{ {
public: public:
static FileStream* openFile(std::string_view path); static FileStream* openFile(std::string_view path);
static FileStream* openFile(const wchar_t* path, bool allowWrite = false); static FileStream* openFile(const wchar_t* path, bool allowWrite = false);
static FileStream* openFile2(const fs::path& path, bool allowWrite = false); static FileStream* openFile2(const fs::path& path, bool allowWrite = false);
static FileStream* createFile(const wchar_t* path); static FileStream* createFile(const wchar_t* path);
static FileStream* createFile(std::string_view path); static FileStream* createFile(std::string_view path);
static FileStream* createFile2(const fs::path& path); static FileStream* createFile2(const fs::path& path);
// helper function to load a file into memory // helper function to load a file into memory
static std::optional<std::vector<uint8>> LoadIntoMemory(const fs::path& path); static std::optional<std::vector<uint8>> LoadIntoMemory(const fs::path& path);
// size and seek // size and seek
void SetPosition(uint64 pos); void SetPosition(uint64 pos);
uint64 GetSize(); uint64 GetSize();
bool SetEndOfFile(); bool SetEndOfFile();
void extract(std::vector<uint8>& data); void extract(std::vector<uint8>& data);
// reading // reading
uint32 readData(void* data, uint32 length); uint32 readData(void* data, uint32 length);
bool readU64(uint64& v); bool readU64(uint64& v);
bool readU32(uint32& v); bool readU32(uint32& v);
bool readU16(uint16& v); bool readU16(uint16& v);
bool readU8(uint8& v); bool readU8(uint8& v);
bool readLine(std::string& line); bool readLine(std::string& line);
// writing (binary) // writing (binary)
sint32 writeData(const void* data, sint32 length); sint32 writeData(const void* data, sint32 length);
void writeU64(uint64 v); void writeU64(uint64 v);
void writeU32(uint32 v); void writeU32(uint32 v);
void writeU16(uint16 v); void writeU16(uint16 v);
void writeU8(uint8 v); void writeU8(uint8 v);
// writing (strings) // writing (strings)
void writeStringFmt(const char* format, ...); void writeStringFmt(const char* format, ...);
void writeString(const char* str); void writeString(const char* str);
void writeLine(const char* str); void writeLine(const char* str);
~FileStream(); ~FileStream();
FileStream() {}; FileStream() {};
private: private:
FileStream(HANDLE hFile); FileStream(HANDLE hFile);
bool m_isValid{}; bool m_isValid{};
HANDLE m_hFile; HANDLE m_hFile;
}; };
#else #else
@ -59,54 +59,54 @@ public:
class FileStream class FileStream
{ {
public: public:
static FileStream* openFile(std::string_view path); static FileStream* openFile(std::string_view path);
static FileStream* openFile(const wchar_t* path, bool allowWrite = false); static FileStream* openFile(const wchar_t* path, bool allowWrite = false);
static FileStream* openFile2(const fs::path& path, bool allowWrite = false); static FileStream* openFile2(const fs::path& path, bool allowWrite = false);
static FileStream* createFile(const wchar_t* path); static FileStream* createFile(const wchar_t* path);
static FileStream* createFile(std::string_view path); static FileStream* createFile(std::string_view path);
static FileStream* createFile2(const fs::path& path); static FileStream* createFile2(const fs::path& path);
// helper function to load a file into memory // helper function to load a file into memory
static std::optional<std::vector<uint8>> LoadIntoMemory(const fs::path& path); static std::optional<std::vector<uint8>> LoadIntoMemory(const fs::path& path);
// size and seek // size and seek
void SetPosition(uint64 pos); void SetPosition(uint64 pos);
uint64 GetSize(); uint64 GetSize();
bool SetEndOfFile(); bool SetEndOfFile();
void extract(std::vector<uint8>& data); void extract(std::vector<uint8>& data);
// reading // reading
uint32 readData(void* data, uint32 length); uint32 readData(void* data, uint32 length);
bool readU64(uint64& v); bool readU64(uint64& v);
bool readU32(uint32& v); bool readU32(uint32& v);
bool readU16(uint16& v); bool readU16(uint16& v);
bool readU8(uint8& v); bool readU8(uint8& v);
bool readLine(std::string& line); bool readLine(std::string& line);
// writing (binary) // writing (binary)
sint32 writeData(const void* data, sint32 length); sint32 writeData(const void* data, sint32 length);
void writeU64(uint64 v); void writeU64(uint64 v);
void writeU32(uint32 v); void writeU32(uint32 v);
void writeU16(uint16 v); void writeU16(uint16 v);
void writeU8(uint8 v); void writeU8(uint8 v);
// writing (strings) // writing (strings)
void writeStringFmt(const char* format, ...); void writeStringFmt(const char* format, ...);
void writeString(const char* str); void writeString(const char* str);
void writeLine(const char* str); void writeLine(const char* str);
~FileStream(); ~FileStream();
FileStream() {}; FileStream() {};
private: private:
void SyncReadWriteSeek(bool nextOpIsWrite); void SyncReadWriteSeek(bool nextOpIsWrite);
FileStream(const fs::path& path, bool isOpen, bool isWriteable); FileStream(const fs::path& path, bool isOpen, bool isWriteable);
bool m_isValid{}; bool m_isValid{};
std::fstream m_fileStream; std::fstream m_fileStream;
bool m_prevOperationWasWrite{false}; bool m_prevOperationWasWrite{false};
}; };