Major project restructuring

Remove unecessary files and made the tree much more cleaner.

Signed-off-by: Ronald Caesar <github43132@proton.me>

core/common/IoFile.cpp

@@ -0,0 +1,492 @@
+// Copyright 2025 Xenon Emulator Project. All rights reserved.
+
+#include <vector>
+
+#include "IoFile.h"
+
+#include "Assert.h"
+#include "Error.h"
+#include "Logging/Log.h"
+#include "PathUtil.h"
+
+#ifdef _WIN32
+#define ftruncate _chsize_s
+#define fsync _commit
+
+#include <Windows.h>
+#include <io.h>
+#include <share.h>
+#else
+#include <unistd.h>
+#endif
+
+#ifdef _MSC_VER
+#define fileno _fileno
+#define fseeko _fseeki64
+#define ftello _ftelli64
+#endif
+
+namespace fs = std::filesystem;
+
+namespace Base::FS
+{
+
+#ifdef _WIN32
+
+[[nodiscard]] constexpr const wchar_t* AccessModeToWStr(FileAccessMode mode, FileMode type)
+{
+    switch (type)
+    {
+        case FileMode::BinaryMode:
+            switch (mode)
+            {
+                case FileAccessMode::Read:
+                    return L"rb";
+                case FileAccessMode::Write:
+                    return L"wb";
+                case FileAccessMode::Append:
+                    return L"ab";
+                case FileAccessMode::ReadWrite:
+                    return L"r+b";
+                case FileAccessMode::ReadAppend:
+                    return L"a+b";
+            }
+            break;
+        case FileMode::TextMode:
+            switch (mode)
+            {
+                case FileAccessMode::Read:
+                    return L"r";
+                case FileAccessMode::Write:
+                    return L"w";
+                case FileAccessMode::Append:
+                    return L"a";
+                case FileAccessMode::ReadWrite:
+                    return L"r+";
+                case FileAccessMode::ReadAppend:
+                    return L"a+";
+            }
+            break;
+    }
+
+    return L"";
+}
+
+[[nodiscard]] constexpr int ToWindowsFileShareFlag(FileShareFlag flag)
+{
+    switch (flag)
+    {
+        case FileShareFlag::ShareNone:
+        default:
+            return _SH_DENYRW;
+        case FileShareFlag::ShareReadOnly:
+            return _SH_DENYWR;
+        case FileShareFlag::ShareWriteOnly:
+            return _SH_DENYRD;
+        case FileShareFlag::ShareReadWrite:
+            return _SH_DENYNO;
+    }
+}
+
+#else
+
+[[nodiscard]] constexpr const char* AccessModeToStr(FileAccessMode mode, FileMode type)
+{
+    switch (type)
+    {
+        case FileMode::BinaryMode:
+            switch (mode)
+            {
+                case FileAccessMode::Read:
+                    return "rb";
+                case FileAccessMode::Write:
+                    return "wb";
+                case FileAccessMode::Append:
+                    return "ab";
+                case FileAccessMode::ReadWrite:
+                    return "r+b";
+                case FileAccessMode::ReadAppend:
+                    return "a+b";
+            }
+            break;
+        case FileMode::TextMode:
+            switch (mode)
+            {
+                case FileAccessMode::Read:
+                    return "r";
+                case FileAccessMode::Write:
+                    return "w";
+                case FileAccessMode::Append:
+                    return "a";
+                case FileAccessMode::ReadWrite:
+                    return "r+";
+                case FileAccessMode::ReadAppend:
+                    return "a+";
+            }
+            break;
+    }
+
+    return "";
+}
+
+#endif
+
+[[nodiscard]] constexpr int ToSeekOrigin(SeekOrigin origin)
+{
+    switch (origin)
+    {
+        case SeekOrigin::SetOrigin:
+        default:
+            return SEEK_SET;
+        case SeekOrigin::CurrentPosition:
+            return SEEK_CUR;
+        case SeekOrigin::End:
+            return SEEK_END;
+    }
+}
+
+IOFile::IOFile() = default;
+
+IOFile::IOFile(const std::string& path, FileAccessMode mode, FileMode type, FileShareFlag flag)
+{
+    Open(path, mode, type, flag);
+}
+
+IOFile::IOFile(std::string_view path, FileAccessMode mode, FileMode type, FileShareFlag flag)
+{
+    Open(path, mode, type, flag);
+}
+
+IOFile::IOFile(const fs::path& path, FileAccessMode mode, FileMode type, FileShareFlag flag)
+{
+    Open(path, mode, type, flag);
+}
+
+IOFile::~IOFile()
+{
+    Close();
+}
+
+IOFile::IOFile(IOFile&& other) noexcept
+{
+    std::swap(filePath, other.filePath);
+    std::swap(fileAccessMode, other.fileAccessMode);
+    std::swap(fileType, other.fileType);
+    std::swap(file, other.file);
+}
+
+IOFile& IOFile::operator=(IOFile&& other) noexcept
+{
+    std::swap(filePath, other.filePath);
+    std::swap(fileAccessMode, other.fileAccessMode);
+    std::swap(fileType, other.fileType);
+    std::swap(file, other.file);
+    return *this;
+}
+
+int IOFile::Open(const fs::path& path, FileAccessMode mode, FileMode type, FileShareFlag flag)
+{
+    Close();
+
+    filePath = path;
+    fileAccessMode = mode;
+    fileType = type;
+
+    errno = 0;
+    int result = 0;
+
+#ifdef _WIN32
+    if (flag != FileShareFlag::ShareNone)
+    {
+        file = ::_wfsopen(path.c_str(), AccessModeToWStr(mode, type), ToWindowsFileShareFlag(flag));
+        result = errno;
+    }
+    else
+    {
+        result = ::_wfopen_s(&file, path.c_str(), AccessModeToWStr(mode, type));
+    }
+#else
+    file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
+    result = errno;
+#endif
+
+    if (!IsOpen())
+    {
+        const auto ec = std::error_code{result, std::generic_category()};
+        LOG_ERROR(Base_Filesystem, "Failed to open the file at path={}, error_message={}", PathToUTF8String(filePath),
+                  ec.message());
+    }
+
+    return result;
+}
+
+void IOFile::Close()
+{
+    if (!IsOpen())
+    {
+        return;
+    }
+
+    errno = 0;
+
+    const bool closeResult = ::fclose(file) == 0;
+
+    if (!closeResult)
+    {
+        const auto ec = std::error_code{errno, std::generic_category()};
+        LOG_ERROR(Base_Filesystem, "Failed to close the file at path={}, ec_message={}", PathToUTF8String(filePath),
+                  ec.message());
+    }
+
+    file = nullptr;
+
+#ifdef _WIN64
+    if (fileMapping && fileAccessMode == FileAccessMode::ReadWrite)
+    {
+        ::CloseHandle(std::bit_cast<HANDLE>(fileMapping));
+    }
+#endif
+}
+
+void IOFile::Unlink()
+{
+    if (!IsOpen())
+    {
+        return;
+    }
+
+    // Mark the file for deletion
+    std::error_code fsError;
+    fs::remove_all(filePath, fsError);
+    if (fsError)
+    {
+        LOG_ERROR(Base_Filesystem, "Failed to remove the file at '{}'. Reason: {}", PathToUTF8String(filePath),
+                  fsError.message());
+    }
+}
+
+uptr IOFile::GetFileMapping()
+{
+    if (fileMapping)
+    {
+        return fileMapping;
+    }
+#ifdef _WIN64
+    const s32 fd = fileno(file);
+
+    HANDLE hfile = reinterpret_cast<HANDLE>(::_get_osfhandle(fd));
+    HANDLE mapping = nullptr;
+
+    /*  if (fileAccessMode == FileAccessMode::ReadWrite) {
+    mapping = CreateFileMapping2(hfile, NULL, FILE_MAP_WRITE, PAGE_READWRITE, SEC_COMMIT, 0,
+                                 NULL, NULL, 0);
+  } else {
+    mapping = hfile;
+  }*/
+
+    mapping = hfile;
+
+    fileMapping = std::bit_cast<uptr>(mapping);
+    ASSERT_MSG(fileMapping, "{}", Base::GetLastErrorMsg());
+    return fileMapping;
+#else
+    fileMapping = fileno(file);
+    return fileMapping;
+#endif
+}
+
+std::string IOFile::ReadString(size_t length) const
+{
+    std::vector<char> string_buffer(length);
+
+    const u64 charsRead = ReadSpan<char>(string_buffer);
+    const auto stringSize = charsRead != length ? charsRead : length;
+
+    return std::string{string_buffer.data(), stringSize};
+}
+
+bool IOFile::Flush() const
+{
+    if (!IsOpen())
+    {
+        return false;
+    }
+
+    errno = 0;
+
+    const bool flushResult = ::fflush(file) == 0;
+
+    if (!flushResult)
+    {
+        const std::error_code ec = {errno, std::generic_category()};
+        LOG_ERROR(Base_Filesystem, "Failed to flush the file at path={}, ec_message={}", PathToUTF8String(filePath),
+                  ec.message());
+    }
+
+    return flushResult;
+}
+
+bool IOFile::Commit() const
+{
+    if (!IsOpen())
+    {
+        return false;
+    }
+
+    errno = 0;
+
+    bool commitResult = ::fflush(file) == 0 && ::fsync(::fileno(file)) == 0;
+
+    if (!commitResult)
+    {
+        const std::error_code ec = {errno, std::generic_category()};
+        LOG_ERROR(Base_Filesystem, "Failed to commit the file at path={}, ec_message={}", PathToUTF8String(filePath),
+                  ec.message());
+    }
+
+    return commitResult;
+}
+
+bool IOFile::SetSize(u64 size) const
+{
+    if (!IsOpen())
+    {
+        return false;
+    }
+
+    errno = 0;
+
+    const bool setSizeResult = ::ftruncate(::fileno(file), static_cast<s64>(size)) == 0;
+
+    if (!setSizeResult)
+    {
+        const std::error_code ec = {errno, std::generic_category()};
+        LOG_ERROR(Base_Filesystem, "Failed to resize the file at path={}, size={}, ec_message={}",
+                  PathToUTF8String(filePath), size, ec.message());
+    }
+
+    return setSizeResult;
+}
+
+u64 IOFile::GetSize() const
+{
+    if (!IsOpen())
+    {
+        return 0;
+    }
+
+    // Flush any unwritten buffered data into the file prior to retrieving the file size.
+    std::fflush(file);
+
+    u64 fSize = 0;
+    // fs::file_size can cause a exception if it is not a valid file
+    try
+    {
+        std::error_code ec{};
+        fSize = fs::file_size(filePath, ec);
+        if (fSize == -1 || !fSize)
+        {
+            LOG_ERROR(Base_Filesystem, "Failed to retrieve the file size of path={}, ec_message={}",
+                      PathToUTF8String(filePath), ec.message());
+            return 0;
+        }
+    }
+    catch (const std::exception& ex)
+    {
+        LOG_ERROR(Base_Filesystem, "Exception trying to get file size. Exception: {}", ex.what());
+        return 0;
+    }
+
+    return fSize;
+}
+
+bool IOFile::Seek(s64 offset, SeekOrigin origin) const
+{
+    if (!IsOpen())
+    {
+        return false;
+    }
+
+    if (False(fileAccessMode & (FileAccessMode::Write | FileAccessMode::Append)))
+    {
+        u64 size = GetSize();
+        if (origin == SeekOrigin::CurrentPosition && Tell() + offset > size)
+        {
+            LOG_ERROR(Base_Filesystem, "Seeking past the end of the file");
+            return false;
+        }
+        else if (origin == SeekOrigin::SetOrigin && static_cast<u64>(offset) > size)
+        {
+            LOG_ERROR(Base_Filesystem, "Seeking past the end of the file");
+            return false;
+        }
+        else if (origin == SeekOrigin::End && offset > 0)
+        {
+            LOG_ERROR(Base_Filesystem, "Seeking past the end of the file");
+            return false;
+        }
+    }
+
+    errno = 0;
+
+    const s32 seekResult = fseeko(file, offset, ToSeekOrigin(origin)) == 0;
+
+    if (!seekResult)
+    {
+        const std::error_code ec = {errno, std::generic_category()};
+        LOG_ERROR(Base_Filesystem, "Failed to seek the file at path={}, offset={}, origin={}, ec_message={}",
+                  PathToUTF8String(filePath), offset, static_cast<u32>(origin), ec.message());
+    }
+
+    return seekResult;
+}
+
+s64 IOFile::Tell() const
+{
+    if (!IsOpen())
+    {
+        return 0;
+    }
+
+    errno = 0;
+
+    return ftello(file);
+}
+
+u64 GetDirectorySize(const std::filesystem::path& path)
+{
+    if (!fs::exists(path))
+    {
+        return 0;
+    }
+
+    u64 total = 0;
+    for (const auto& entry : fs::recursive_directory_iterator(path))
+    {
+        if (fs::is_regular_file(entry.path()))
+        {
+            // fs::file_size can cause a exception if it is not a valid file
+            try
+            {
+                std::error_code ec{};
+                u64 fileSize = fs::file_size(entry.path(), ec);
+                if (fileSize != -1 && fileSize)
+                {
+                    total += fileSize;
+                }
+                else
+                {
+                    LOG_ERROR(Base_Filesystem, "Failed to retrieve the file size of path={}, ec_message={}",
+                              PathToUTF8String(entry.path()), ec.message());
+                }
+            }
+            catch (const std::exception& ex)
+            {
+                LOG_ERROR(Base_Filesystem, "Exception trying to get file size. Exception: {}", ex.what());
+            }
+        }
+    }
+    return total;
+}
+
+}  // namespace Base::FS