Plexi09/eden-miror
1
0
Fork 0
mirror of https://git.eden-emu.dev/eden-emu/eden synced 2026-04-21 18:58:57 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Add for windows and Android

Browse source
This commit is contained in:
lizzie 2025-12-26 11:30:25 +00:00 • committed by crueter
parent d29daabad5
commit ae44a71fee
2 changed files with 355 additions and 324 deletions
Download patch file Download diff file Expand all files Collapse all files

227
src/common/fs/file.cpp
View file

@ -18,6 +18,7 @@
#ifdef _WIN32 #ifdef _WIN32
#include <io.h> #include <io.h>
#include <share.h> #include <share.h>
#include <windows.h>
#else #else
#include <unistd.h> #include <unistd.h>
#include <sys/mman.h> #include <sys/mman.h>
@ -40,13 +41,13 @@ namespace {
#ifdef _WIN32 #ifdef _WIN32
/** /**
* Converts the file access mode and file type enums to a file access mode wide string. * Converts the file access mode and file type enums to a file access mode wide string.
* *
* @param mode File access mode * @param mode File access mode
* @param type File type * @param type File type
* *
* @returns A pointer to a wide string representing the file access mode. * @returns A pointer to a wide string representing the file access mode.
*/ */
[[nodiscard]] constexpr const wchar_t* AccessModeToWStr(FileAccessMode mode, FileType type) { [[nodiscard]] constexpr const wchar_t* AccessModeToWStr(FileAccessMode mode, FileType type) {
switch (type) { switch (type) {
case FileType::BinaryFile: case FileType::BinaryFile:
@ -83,12 +84,12 @@ namespace {
} }
/** /**
* Converts the file-share access flag enum to a Windows defined file-share access flag. * Converts the file-share access flag enum to a Windows defined file-share access flag.
* *
* @param flag File-share access flag * @param flag File-share access flag
* *
* @returns Windows defined file-share access flag. * @returns Windows defined file-share access flag.
*/ */
[[nodiscard]] constexpr int ToWindowsFileShareFlag(FileShareFlag flag) { [[nodiscard]] constexpr int ToWindowsFileShareFlag(FileShareFlag flag) {
switch (flag) { switch (flag) {
case FileShareFlag::ShareNone: case FileShareFlag::ShareNone:
@ -106,13 +107,13 @@ namespace {
#else #else
/** /**
* Converts the file access mode and file type enums to a file access mode string. * Converts the file access mode and file type enums to a file access mode string.
* *
* @param mode File access mode * @param mode File access mode
* @param type File type * @param type File type
* *
* @returns A pointer to a string representing the file access mode. * @returns A pointer to a string representing the file access mode.
*/ */
[[nodiscard]] constexpr const char* AccessModeToStr(FileAccessMode mode, FileType type) { [[nodiscard]] constexpr const char* AccessModeToStr(FileAccessMode mode, FileType type) {
switch (type) { switch (type) {
case FileType::BinaryFile: case FileType::BinaryFile:
@ -151,12 +152,12 @@ namespace {
#endif #endif
/** /**
* Converts the seek origin enum to a seek origin integer. * Converts the seek origin enum to a seek origin integer.
* *
* @param origin Seek origin * @param origin Seek origin
* *
* @returns Seek origin integer. * @returns Seek origin integer.
*/ */
[[nodiscard]] constexpr int ToSeekOrigin(SeekOrigin origin) { [[nodiscard]] constexpr int ToSeekOrigin(SeekOrigin origin) {
switch (origin) { switch (origin) {
case SeekOrigin::SetOrigin: case SeekOrigin::SetOrigin:
@ -182,7 +183,7 @@ std::string ReadStringFromFile(const std::filesystem::path& path, FileType type)
} }
size_t WriteStringToFile(const std::filesystem::path& path, FileType type, size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
std::string_view string) { std::string_view string) {
if (Exists(path) && !IsFile(path)) { if (Exists(path) && !IsFile(path)) {
return 0; return 0;
} }
@ -193,7 +194,7 @@ size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
} }
size_t AppendStringToFile(const std::filesystem::path& path, FileType type, size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
std::string_view string) { std::string_view string) {
if (Exists(path) && !IsFile(path)) { if (Exists(path) && !IsFile(path)) {
return 0; return 0;
} }
@ -248,40 +249,13 @@ FileType IOFile::GetType() const {
return file_type; return file_type;
} }
void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) { #ifdef __unix__
Close(); int PlatformMapReadOnly(IOFile& io, const char* path) {
file_path = path; io.mmap_fd = open(path., O_RDONLY);
file_access_mode = mode; if (io.mmap_fd > 0) {
file_type = type;
errno = 0;
#ifdef _WIN32
if (flag != FileShareFlag::ShareNone) {
file = _wfsopen(path.c_str(), AccessModeToWStr(mode, type), ToWindowsFileShareFlag(flag));
} else {
_wfopen_s(&file, path.c_str(), AccessModeToWStr(mode, type));
}
#elif ANDROID
if (Android::IsContentUri(path)) {
ASSERT_MSG(mode == FileAccessMode::Read, "Content URI file access is for read-only!");
auto const fd = Android::OpenContentUri(path, Android::OpenMode::Read);
if (fd != -1) {
file = fdopen(fd, "r");
if (errno != 0 && file == nullptr)
LOG_ERROR(Common_Filesystem, "Error opening file: {}, error: {}", path.c_str(), strerror(errno));
} else {
LOG_ERROR(Common_Filesystem, "Error opening file: {}", path.c_str());
}
} else {
file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
}
#elif defined(__HAIKU__) || defined(__managarm__) || defined(__OPENORBIS__) || defined(__APPLE__)
file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
#elif defined(__unix__)
if (type == FileType::BinaryFile && mode == FileAccessMode::Read) {
struct stat st; struct stat st;
mmap_fd = open(path.c_str(), O_RDONLY); fstat(io.mmap_fd, &st);
fstat(mmap_fd, &st); io.mmap_size = st.st_size;
mmap_size = st.st_size;
int map_flags = MAP_PRIVATE; int map_flags = MAP_PRIVATE;
#ifdef MAP_PREFAULT_READ #ifdef MAP_PREFAULT_READ
@ -315,18 +289,97 @@ void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, File
u64 big_file_threshold = 512_MiB; u64 big_file_threshold = 512_MiB;
map_flags |= u64(st.st_size) >= big_file_threshold ? MAP_ALIGNED_SUPER : 0; map_flags |= u64(st.st_size) >= big_file_threshold ? MAP_ALIGNED_SUPER : 0;
#endif #endif
mmap_base = (u8*)mmap(nullptr, mmap_size, PROT_READ, map_flags, mmap_fd, 0); io.mmap_base = (u8*)mmap(nullptr, io.mmap_size, PROT_READ, map_flags, io.mmap_fd, 0);
if (mmap_base == MAP_FAILED) { if (io.mmap_base == MAP_FAILED) {
close(mmap_fd); close(io.mmap_fd);
mmap_fd = -1; io.mmap_fd = -1;
} else { } else {
posix_madvise(mmap_base, mmap_size, POSIX_MADV_WILLNEED); posix_madvise(mmap_base, io.mmap_size, POSIX_MADV_WILLNEED);
} }
} }
// mmap(2) failed or simply we can't use it return io.mmap_fd;
if (mmap_fd == -1) { }
void PlatformUnmap(IOFile& io) {
if (io.mmap_fd != -1) {
munmap(io.mmap_base, io.mmap_size);
close(io.mmap_fd);
io.mmap_fd = -1;
}
}
#else
int PlatformMapReadOnly(IOFile& io, const char* path) {
io.file_handle = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, nullptr);
if (HANDLE(io.file_handle) != INVALID_HANDLE_VALUE) {
io.mapping_handle = CreateFileMappingW(file_handle, nullptr, PAGE_READONLY, 0, 0, nullptr);
if (io.mapping_handle) {
io.mmap_base = (char const*)MapViewOfFile(HANDLE(io.mapping_handle), FILE_MAP_READ, 0, 0, 0);
if (io.mmap_base) {
_LARGE_INTEGER pvalue;
GetFileSizeEx(file_handle, &pvalue);
io.mmap_size = uint32_t(pvalue.QuadPart);
} else {
CloseHandle(io.mapping_handle);
CloseHandle(io.file_handle);
return -1;
}
} else {
CloseHandle(io.file_handle);
return -1;
}
}
return 0;
}
void PlatformUnmap(IOFile& io) {
if(io.mapping_handle) {
if(io.mmap_base)
UnmapViewOfFile(HANDLE(io.mmap_base));
CloseHandle(HANDLE(io.mapping_handle));
}
if(io.file_handle != INVALID_HANDLE_VALUE)
CloseHandle(HANDLE(io.file_handle));
}
#endif
void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
Close();
file_path = path;
file_access_mode = mode;
file_type = type;
errno = 0;
#ifdef _WIN32
if (flag != FileShareFlag::ShareNone) {
file = _wfsopen(path.c_str(), AccessModeToWStr(mode, type), ToWindowsFileShareFlag(flag));
} else {
_wfopen_s(&file, path.c_str(), AccessModeToWStr(mode, type));
}
#elif ANDROID
if (Android::IsContentUri(path)) {
ASSERT_MSG(mode == FileAccessMode::Read, "Content URI file access is for read-only!");
if (PlatformMapReadOnly(*this, path.c_str()) == -1) {
LOG_ERROR(Common_Filesystem, "Error mmap'ing file: {}", path.c_str());
int const fd = Android::OpenContentUri(path, Android::OpenMode::Read);
if (fd != -1) {
file = fdopen(fd, "r");
if (errno != 0 && file == nullptr)
LOG_ERROR(Common_Filesystem, "Error opening file: {}, error: {}", path.c_str(), strerror(errno));
} else {
LOG_ERROR(Common_Filesystem, "Error opening file: {}", path.c_str());
}
}
} else {
file = std::fopen(path.c_str(), AccessModeToStr(mode, type)); file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
} }
#elif defined(__HAIKU__) || defined(__managarm__) || defined(__OPENORBIS__) || defined(__APPLE__)
file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
#elif defined(__unix__)
if (type == FileType::BinaryFile && mode == FileAccessMode::Read) {
if (PlatformMapReadOnly(*this, path.c_str()) == -1) {
LOG_ERROR(Common_Filesystem, "Error mmap'ing file: {}", path.c_str());
}
}
if (mmap_fd == -1) {
file = std::fopen(path.c_str(), AccessModeToStr(mode, type)); // mmap(2) failed or simply we can't use it
}
#else #else
// Some other fancy OS (ahem fucking Darwin/Mac OSX) // Some other fancy OS (ahem fucking Darwin/Mac OSX)
file = std::fopen(path.c_str(), AccessModeToStr(mode, type)); file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
@ -339,13 +392,7 @@ void IOFile::Open(const fs::path& path, FileAccessMode mode, FileType type, File
} }
void IOFile::Close() { void IOFile::Close() {
#ifdef __unix__ PlatformUnmap(*this);
if (mmap_fd != -1) {
munmap(mmap_base, mmap_size);
close(mmap_fd);
mmap_fd = -1;
}
#endif
if (file) { if (file) {
errno = 0; errno = 0;
const auto close_result = std::fclose(file) == 0; const auto close_result = std::fclose(file) == 0;
@ -359,11 +406,7 @@ void IOFile::Close() {
} }
bool IOFile::IsOpen() const { bool IOFile::IsOpen() const {
#ifdef __unix__ return file != nullptr || IsMappedFile();
return file != nullptr || mmap_fd != -1;
#else
return file != nullptr;
#endif
} }
std::string IOFile::ReadString(size_t length) const { std::string IOFile::ReadString(size_t length) const {
@ -380,9 +423,7 @@ size_t IOFile::WriteString(std::span<const char> string) const {
} }
bool IOFile::Flush() const { bool IOFile::Flush() const {
#ifdef __unix__ ASSERT(!IsMappedFile());
ASSERT(mmap_fd == -1);
#endif
if (file) { if (file) {
errno = 0; errno = 0;
auto const flush_result = std::fflush(file) == 0; auto const flush_result = std::fflush(file) == 0;
@ -397,9 +438,7 @@ bool IOFile::Flush() const {
} }
bool IOFile::Commit() const { bool IOFile::Commit() const {
#ifdef __unix__ ASSERT(!IsMappedFile());
ASSERT(mmap_fd == -1);
#endif
if (file) { if (file) {
errno = 0; errno = 0;
#ifdef _WIN32 #ifdef _WIN32
@ -418,9 +457,7 @@ bool IOFile::Commit() const {
} }
bool IOFile::SetSize(u64 size) const { bool IOFile::SetSize(u64 size) const {
#ifdef __unix__ ASSERT(!IsMappedFile());
ASSERT(mmap_fd == -1);
#endif
if (file) { if (file) {
errno = 0; errno = 0;
#ifdef _WIN32 #ifdef _WIN32
@ -439,10 +476,8 @@ bool IOFile::SetSize(u64 size) const {
} }
u64 IOFile::GetSize() const { u64 IOFile::GetSize() const {
#ifdef __unix__ if (IsMappedFile())
if (mmap_fd != -1)
return mmap_size; return mmap_size;
#endif
if (file) { if (file) {
// Flush any unwritten buffered data into the file prior to retrieving the file mmap_size. // Flush any unwritten buffered data into the file prior to retrieving the file mmap_size.
std::fflush(file); std::fflush(file);
@ -476,8 +511,7 @@ u64 IOFile::GetSize() const {
} }
bool IOFile::Seek(s64 offset, SeekOrigin origin) const { bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
#ifdef __unix__ if (IsMappedFile()) {
if (mmap_fd != -1) {
// fuck you to whoever made this method const // fuck you to whoever made this method const
switch (origin) { switch (origin) {
case SeekOrigin::SetOrigin: case SeekOrigin::SetOrigin:
@ -492,7 +526,6 @@ bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
} }
return true; return true;
} }
#endif
if (file) { if (file) {
errno = 0; errno = 0;
const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0; const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0;
@ -507,12 +540,10 @@ bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
} }
s64 IOFile::Tell() const { s64 IOFile::Tell() const {
#ifdef __unix__ if (IsMappedFile()) {
if (mmap_fd != -1) {
errno = 0; errno = 0;
return s64(mmap_offset); return s64(mmap_offset);
} }
#endif
if (file) { if (file) {
errno = 0; errno = 0;
return ftello(file); return ftello(file);

452
src/common/fs/file.h
View file

@ -25,12 +25,12 @@ enum class SeekOrigin {
}; };
/** /**
* Opens a file stream at path with the specified open mode. * Opens a file stream at path with the specified open mode.
* *
* @param file_stream Reference to file stream * @param file_stream Reference to file stream
* @param path Filesystem path * @param path Filesystem path
* @param open_mode File stream open mode * @param open_mode File stream open mode
*/ */
template <typename FileStream> template <typename FileStream>
void OpenFileStream(FileStream& file_stream, const std::filesystem::path& path, void OpenFileStream(FileStream& file_stream, const std::filesystem::path& path,
std::ios_base::openmode open_mode) { std::ios_base::openmode open_mode) {
@ -49,14 +49,14 @@ void OpenFileStream(FileStream& file_stream, const Path& path, std::ios_base::op
#endif #endif
/** /**
* Reads an entire file at path and returns a string of the contents read from the file. * Reads an entire file at path and returns a string of the contents read from the file.
* If the filesystem object at path is not a regular file, this function returns an empty string. * If the filesystem object at path is not a regular file, this function returns an empty string.
* *
* @param path Filesystem path * @param path Filesystem path
* @param type File type * @param type File type
* *
* @returns A string of the contents read from the file. * @returns A string of the contents read from the file.
*/ */
[[nodiscard]] std::string ReadStringFromFile(const std::filesystem::path& path, FileType type); [[nodiscard]] std::string ReadStringFromFile(const std::filesystem::path& path, FileType type);
#ifdef _WIN32 #ifdef _WIN32
@ -71,18 +71,18 @@ template <typename Path>
#endif #endif
/** /**
* Writes a string to a file at path and returns the number of characters successfully written. * Writes a string to a file at path and returns the number of characters successfully written.
* If a file already exists at path, its contents will be erased. * If a file already exists at path, its contents will be erased.
* If a file does not exist at path, it creates and opens a new empty file for writing. * If a file does not exist at path, it creates and opens a new empty file for writing.
* If the filesystem object at path exists and is not a regular file, this function returns 0. * If the filesystem object at path exists and is not a regular file, this function returns 0.
* *
* @param path Filesystem path * @param path Filesystem path
* @param type File type * @param type File type
* *
* @returns Number of characters successfully written. * @returns Number of characters successfully written.
*/ */
[[nodiscard]] size_t WriteStringToFile(const std::filesystem::path& path, FileType type, [[nodiscard]] size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
std::string_view string); std::string_view string);
#ifdef _WIN32 #ifdef _WIN32
template <typename Path> template <typename Path>
@ -96,15 +96,15 @@ template <typename Path>
#endif #endif
/** /**
* Appends a string to a file at path and returns the number of characters successfully written. * Appends a string to a file at path and returns the number of characters successfully written.
* If a file does not exist at path, it creates and opens a new empty file for appending. * If a file does not exist at path, it creates and opens a new empty file for appending.
* If the filesystem object at path exists and is not a regular file, this function returns 0. * If the filesystem object at path exists and is not a regular file, this function returns 0.
* *
* @param path Filesystem path * @param path Filesystem path
* @param type File type * @param type File type
* *
* @returns Number of characters successfully written. * @returns Number of characters successfully written.
*/ */
[[nodiscard]] size_t AppendStringToFile(const std::filesystem::path& path, FileType type, [[nodiscard]] size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
std::string_view string); std::string_view string);
@ -132,14 +132,14 @@ public:
FileShareFlag flag = FileShareFlag::ShareReadOnly); FileShareFlag flag = FileShareFlag::ShareReadOnly);
/** /**
* An IOFile is a lightweight wrapper on C Library file operations. * An IOFile is a lightweight wrapper on C Library file operations.
* Automatically closes an open file on the destruction of an IOFile object. * Automatically closes an open file on the destruction of an IOFile object.
* *
* @param path Filesystem path * @param path Filesystem path
* @param mode File access mode * @param mode File access mode
* @param type File type, default is BinaryFile. Use TextFile to open the file as a text file * @param type File type, default is BinaryFile. Use TextFile to open the file as a text file
* @param flag (Windows only) File-share access flag, default is ShareReadOnly * @param flag (Windows only) File-share access flag, default is ShareReadOnly
*/ */
explicit IOFile(const std::filesystem::path& path, FileAccessMode mode, explicit IOFile(const std::filesystem::path& path, FileAccessMode mode,
FileType type = FileType::BinaryFile, FileType type = FileType::BinaryFile,
FileShareFlag flag = FileShareFlag::ShareReadOnly); FileShareFlag flag = FileShareFlag::ShareReadOnly);
@ -153,65 +153,65 @@ public:
IOFile& operator=(IOFile&& other) noexcept; IOFile& operator=(IOFile&& other) noexcept;
/** /**
* Gets the path of the file. * Gets the path of the file.
* *
* @returns The path of the file. * @returns The path of the file.
*/ */
[[nodiscard]] std::filesystem::path GetPath() const; [[nodiscard]] std::filesystem::path GetPath() const;
/** /**
* Gets the access mode of the file. * Gets the access mode of the file.
* *
* @returns The access mode of the file. * @returns The access mode of the file.
*/ */
[[nodiscard]] FileAccessMode GetAccessMode() const; [[nodiscard]] FileAccessMode GetAccessMode() const;
/** /**
* Gets the type of the file. * Gets the type of the file.
* *
* @returns The type of the file. * @returns The type of the file.
*/ */
[[nodiscard]] FileType GetType() const; [[nodiscard]] FileType GetType() const;
/** /**
* Opens a file at path with the specified file access mode. * Opens a file at path with the specified file access mode.
* This function behaves differently depending on the FileAccessMode. * This function behaves differently depending on the FileAccessMode.
* These behaviors are documented in each enum value of FileAccessMode. * These behaviors are documented in each enum value of FileAccessMode.
* *
* @param path Filesystem path * @param path Filesystem path
* @param mode File access mode * @param mode File access mode
* @param type File type, default is BinaryFile. Use TextFile to open the file as a text file * @param type File type, default is BinaryFile. Use TextFile to open the file as a text file
* @param flag (Windows only) File-share access flag, default is ShareReadOnly * @param flag (Windows only) File-share access flag, default is ShareReadOnly
*/ */
void Open(const std::filesystem::path& path, FileAccessMode mode, void Open(const std::filesystem::path& path, FileAccessMode mode,
FileType type = FileType::BinaryFile, FileType type = FileType::BinaryFile,
FileShareFlag flag = FileShareFlag::ShareReadOnly); FileShareFlag flag = FileShareFlag::ShareReadOnly);
/// Closes the file if it is opened. /// Closes the file if it is opened.
void Close(); void Close();
/** /**
* Checks whether the file is open. * Checks whether the file is open.
* Use this to check whether the calls to Open() or Close() succeeded. * Use this to check whether the calls to Open() or Close() succeeded.
* *
* @returns True if the file is open, false otherwise. * @returns True if the file is open, false otherwise.
*/ */
[[nodiscard]] bool IsOpen() const; [[nodiscard]] bool IsOpen() const;
/** /**
* Helper function which deduces the value type of a contiguous STL container used in ReadSpan. * Helper function which deduces the value type of a contiguous STL container used in ReadSpan.
* If T is not a contiguous container as defined by the concept IsContiguousContainer, this * If T is not a contiguous container as defined by the concept IsContiguousContainer, this
* calls ReadObject and T must be a trivially copyable object. * calls ReadObject and T must be a trivially copyable object.
* *
* See ReadSpan for more details if T is a contiguous container. * See ReadSpan for more details if T is a contiguous container.
* See ReadObject for more details if T is a trivially copyable object. * See ReadObject for more details if T is a trivially copyable object.
* *
* @tparam T Contiguous container or trivially copyable object * @tparam T Contiguous container or trivially copyable object
* *
* @param data Container of T::value_type data or reference to object * @param data Container of T::value_type data or reference to object
* *
* @returns Count of T::value_type data or objects successfully read. * @returns Count of T::value_type data or objects successfully read.
*/ */
template <typename T> template <typename T>
[[nodiscard]] size_t Read(T& data) const { [[nodiscard]] size_t Read(T& data) const {
if constexpr (IsContiguousContainer<T>) { if constexpr (IsContiguousContainer<T>) {
@ -224,19 +224,19 @@ public:
} }
/** /**
* Helper function which deduces the value type of a contiguous STL container used in WriteSpan. * Helper function which deduces the value type of a contiguous STL container used in WriteSpan.
* If T is not a contiguous STL container as defined by the concept IsContiguousContainer, this * If T is not a contiguous STL container as defined by the concept IsContiguousContainer, this
* calls WriteObject and T must be a trivially copyable object. * calls WriteObject and T must be a trivially copyable object.
* *
* See WriteSpan for more details if T is a contiguous container. * See WriteSpan for more details if T is a contiguous container.
* See WriteObject for more details if T is a trivially copyable object. * See WriteObject for more details if T is a trivially copyable object.
* *
* @tparam T Contiguous container or trivially copyable object * @tparam T Contiguous container or trivially copyable object
* *
* @param data Container of T::value_type data or const reference to object * @param data Container of T::value_type data or const reference to object
* *
* @returns Count of T::value_type data or objects successfully written. * @returns Count of T::value_type data or objects successfully written.
*/ */
template <typename T> template <typename T>
[[nodiscard]] size_t Write(const T& data) const { [[nodiscard]] size_t Write(const T& data) const {
if constexpr (IsContiguousContainer<T>) { if constexpr (IsContiguousContainer<T>) {
@ -250,195 +250,187 @@ public:
} }
/** /**
* Reads a span of T data from a file sequentially. * Reads a span of T data from a file sequentially.
* This function reads from the current position of the file pointer and * This function reads from the current position of the file pointer and
* advances it by the (count of T * sizeof(T)) bytes successfully read. * advances it by the (count of T * sizeof(T)) bytes successfully read.
* *
* Failures occur when: * Failures occur when:
* - The file is not open * - The file is not open
* - The opened file lacks read permissions * - The opened file lacks read permissions
* - Attempting to read beyond the end-of-file * - Attempting to read beyond the end-of-file
* *
* @tparam T Data type * @tparam T Data type
* *
* @param data Span of T data * @param data Span of T data
* *
* @returns Count of T data successfully read. * @returns Count of T data successfully read.
*/ */
template <typename T> template <typename T>
[[nodiscard]] size_t ReadSpan(std::span<T> data) const { [[nodiscard]] size_t ReadSpan(std::span<T> data) const {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
#ifdef __unix__ if (IsMappedFile()) {
if (mmap_fd != -1) {
std::memcpy(data.data(), mmap_base + mmap_offset, sizeof(T) * data.size()); std::memcpy(data.data(), mmap_base + mmap_offset, sizeof(T) * data.size());
return data.size(); return data.size();
} }
#endif
return IsOpen() ? std::fread(data.data(), sizeof(T), data.size(), file) : 0; return IsOpen() ? std::fread(data.data(), sizeof(T), data.size(), file) : 0;
} }
/** /**
* Writes a span of T data to a file sequentially. * Writes a span of T data to a file sequentially.
* This function writes from the current position of the file pointer and * This function writes from the current position of the file pointer and
* advances it by the (count of T * sizeof(T)) bytes successfully written. * advances it by the (count of T * sizeof(T)) bytes successfully written.
* *
* Failures occur when: * Failures occur when:
* - The file is not open * - The file is not open
* - The opened file lacks write permissions * - The opened file lacks write permissions
* *
* @tparam T Data type * @tparam T Data type
* *
* @param data Span of T data * @param data Span of T data
* *
* @returns Count of T data successfully written. * @returns Count of T data successfully written.
*/ */
template <typename T> template <typename T>
[[nodiscard]] size_t WriteSpan(std::span<const T> data) const { [[nodiscard]] size_t WriteSpan(std::span<const T> data) const {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
#ifdef __unix__ if (IsMappedFile()) {
if (mmap_fd != -1) {
std::memcpy(mmap_base + mmap_offset, data.data(), sizeof(T) * data.size()); std::memcpy(mmap_base + mmap_offset, data.data(), sizeof(T) * data.size());
return data.size(); return data.size();
} }
#endif
return IsOpen() ? std::fwrite(data.data(), sizeof(T), data.size(), file) : 0; return IsOpen() ? std::fwrite(data.data(), sizeof(T), data.size(), file) : 0;
} }
/** /**
* Reads a T object from a file sequentially. * Reads a T object from a file sequentially.
* This function reads from the current position of the file pointer and * This function reads from the current position of the file pointer and
* advances it by the sizeof(T) bytes successfully read. * advances it by the sizeof(T) bytes successfully read.
* *
* Failures occur when: * Failures occur when:
* - The file is not open * - The file is not open
* - The opened file lacks read permissions * - The opened file lacks read permissions
* - Attempting to read beyond the end-of-file * - Attempting to read beyond the end-of-file
* *
* @tparam T Data type * @tparam T Data type
* *
* @param object Reference to object * @param object Reference to object
* *
* @returns True if the object is successfully read from the file, false otherwise. * @returns True if the object is successfully read from the file, false otherwise.
*/ */
template <typename T> template <typename T>
[[nodiscard]] bool ReadObject(T& object) const { [[nodiscard]] bool ReadObject(T& object) const {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object."); static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
#ifdef __unix__ if (IsMappedFile()) {
if (mmap_fd != -1) {
std::memcpy(&object, mmap_base + mmap_offset, sizeof(T)); std::memcpy(&object, mmap_base + mmap_offset, sizeof(T));
return sizeof(T); return sizeof(T);
} }
#endif
return IsOpen() ? std::fread(&object, sizeof(T), 1, file) == 1 : false; return IsOpen() ? std::fread(&object, sizeof(T), 1, file) == 1 : false;
} }
/** /**
* Writes a T object to a file sequentially. * Writes a T object to a file sequentially.
* This function writes from the current position of the file pointer and * This function writes from the current position of the file pointer and
* advances it by the sizeof(T) bytes successfully written. * advances it by the sizeof(T) bytes successfully written.
* *
* Failures occur when: * Failures occur when:
* - The file is not open * - The file is not open
* - The opened file lacks write permissions * - The opened file lacks write permissions
* *
* @tparam T Data type * @tparam T Data type
* *
* @param object Const reference to object * @param object Const reference to object
* *
* @returns True if the object is successfully written to the file, false otherwise. * @returns True if the object is successfully written to the file, false otherwise.
*/ */
template <typename T> template <typename T>
[[nodiscard]] bool WriteObject(const T& object) const { [[nodiscard]] bool WriteObject(const T& object) const {
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable."); static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object."); static_assert(!std::is_pointer_v<T>, "T must not be a pointer to an object.");
#ifdef __unix__ if (IsMappedFile()) {
if (mmap_fd != -1) {
std::memcpy(mmap_base + mmap_offset, &object, sizeof(T)); std::memcpy(mmap_base + mmap_offset, &object, sizeof(T));
return sizeof(T); return sizeof(T);
} }
#endif
return IsOpen() ? std::fwrite(&object, sizeof(T), 1, file) == 1 : false; return IsOpen() ? std::fwrite(&object, sizeof(T), 1, file) == 1 : false;
} }
/** /**
* Specialized function to read a string of a given length from a file sequentially. * Specialized function to read a string of a given length from a file sequentially.
* This function writes from the current position of the file pointer and * This function writes from the current position of the file pointer and
* advances it by the number of characters successfully read. * advances it by the number of characters successfully read.
* The size of the returned string may not match length if not all bytes are successfully read. * The size of the returned string may not match length if not all bytes are successfully read.
* *
* @param length Length of the string * @param length Length of the string
* *
* @returns A string read from the file. * @returns A string read from the file.
*/ */
[[nodiscard]] std::string ReadString(size_t length) const; [[nodiscard]] std::string ReadString(size_t length) const;
/** /**
* Specialized function to write a string to a file sequentially. * Specialized function to write a string to a file sequentially.
* This function writes from the current position of the file pointer and * This function writes from the current position of the file pointer and
* advances it by the number of characters successfully written. * advances it by the number of characters successfully written.
* *
* @param string Span of const char backed std::string or std::string_view * @param string Span of const char backed std::string or std::string_view
* *
* @returns Number of characters successfully written. * @returns Number of characters successfully written.
*/ */
[[nodiscard]] size_t WriteString(std::span<const char> string) const; [[nodiscard]] size_t WriteString(std::span<const char> string) const;
/** /**
* Attempts to flush any unwritten buffered data into the file. * Attempts to flush any unwritten buffered data into the file.
* *
* @returns True if the flush was successful, false otherwise. * @returns True if the flush was successful, false otherwise.
*/ */
bool Flush() const; bool Flush() const;
/** /**
* Attempts to commit the file into the disk. * Attempts to commit the file into the disk.
* Note that this is an expensive operation as this forces the operating system to write * Note that this is an expensive operation as this forces the operating system to write
* the contents of the file associated with the file descriptor into the disk. * the contents of the file associated with the file descriptor into the disk.
* *
* @returns True if the commit was successful, false otherwise. * @returns True if the commit was successful, false otherwise.
*/ */
bool Commit() const; bool Commit() const;
/** /**
* Resizes the file to a given size. * Resizes the file to a given size.
* If the file is resized to a smaller size, the remainder of the file is discarded. * If the file is resized to a smaller size, the remainder of the file is discarded.
* If the file is resized to a larger size, the new area appears as if zero-filled. * If the file is resized to a larger size, the new area appears as if zero-filled.
* *
* Failures occur when: * Failures occur when:
* - The file is not open * - The file is not open
* *
* @param size File size in bytes * @param size File size in bytes
* *
* @returns True if the file resize succeeded, false otherwise. * @returns True if the file resize succeeded, false otherwise.
*/ */
[[nodiscard]] bool SetSize(u64 size) const; [[nodiscard]] bool SetSize(u64 size) const;
/** /**
* Gets the size of the file. * Gets the size of the file.
* *
* Failures occur when: * Failures occur when:
* - The file is not open * - The file is not open
* *
* @returns The file size in bytes of the file. Returns 0 on failure. * @returns The file size in bytes of the file. Returns 0 on failure.
*/ */
[[nodiscard]] u64 GetSize() const; [[nodiscard]] u64 GetSize() const;
/** /**
* Moves the current position of the file pointer with the specified offset and seek origin. * Moves the current position of the file pointer with the specified offset and seek origin.
* *
* @param offset Offset from seek origin * @param offset Offset from seek origin
* @param origin Seek origin * @param origin Seek origin
* *
* @returns True if the file pointer has moved to the specified offset, false otherwise. * @returns True if the file pointer has moved to the specified offset, false otherwise.
*/ */
[[nodiscard]] bool Seek(s64 offset, SeekOrigin origin = SeekOrigin::SetOrigin) const; [[nodiscard]] bool Seek(s64 offset, SeekOrigin origin = SeekOrigin::SetOrigin) const;
/** /**
* Gets the current position of the file pointer. * Gets the current position of the file pointer.
* *
* @returns The current position of the file pointer. * @returns The current position of the file pointer.
*/ */
[[nodiscard]] s64 Tell() const; [[nodiscard]] s64 Tell() const;
private: private:
@ -446,13 +438,21 @@ private:
FileAccessMode file_access_mode{}; FileAccessMode file_access_mode{};
FileType file_type{}; FileType file_type{};
std::FILE* file = nullptr; std::FILE* file = nullptr;
#ifdef __unix__
// Any decent system should have mmap() for files
// Systems with artifical mmap() limitations should simply change the logic within file.cpp
// and reduce the threshold for which the mmap() is set to
#ifdef _WIN32
void *mapping_handle = nullptr;
void *file_handle = nullptr;
bool IsMappedFile() { return file_handle != nullptr; }
#else // POSIX
int mmap_fd = -1; int mmap_fd = -1;
bool IsMappedFile() { return mmap_fd != -1; }
#endif
u8* mmap_base = nullptr; u8* mmap_base = nullptr;
size_t mmap_size = 0; size_t mmap_size = 0;
// fuck you mutable off_t mmap_offset = 0; // fuck you
mutable off_t mmap_offset = 0;
#endif
}; };
} // namespace Common::FS } // namespace Common::FS