Add error messages in places where only error codes were previously logged (e.g. load a C++ mod) (#902)

Xebeth · web-flow · commit 2e365b88f3aa · 2025-06-09T16:29:16.000+02:00
diff --git a/UE4SS/proxy_generator/main.cpp b/UE4SS/proxy_generator/main.cpp
@@ -15,6 +15,8 @@
 #include <Windows.h>
 #include <ImageHlp.h>
 #include <tchar.h>
+#include <Helpers/String.hpp>
+#include <Helpers/Win32Error.hpp>
 
 using namespace RC;
 namespace fs = std::filesystem;
@@ -49,7 +51,8 @@ std::vector<ExportFunction> DumpExports(const fs::path& dll_path)
 
     if (export_directory == nullptr)
     {
-        cerr << std::format("Failed to get export directory, reason: {:x}", GetLastError()) << endl;
+        auto err_msg = to_string(Win32Error(GetLastError()));
+        cerr << std::format("Failed to get export directory, reason: {}", err_msg) << '\n';
         return {};
     }
 
diff --git a/UE4SS/src/CrashDumper.cpp b/UE4SS/src/CrashDumper.cpp
@@ -2,13 +2,12 @@
 #include <string>
 #include <format>
 #include <bit>
-#include <fmt/chrono.h>
 #include <UE4SSProgram.hpp>
 #include <Unreal/Core/Windows/WindowsHWrapper.hpp>
 
 #include <polyhook2/PE/IatHook.hpp>
 #include <dbghelp.h>
-
+#include <Helpers/Win32Error.hpp>
 #include <String/StringType.hpp>
 
 namespace fs = std::filesystem;
@@ -34,7 +33,7 @@ namespace RC
 
         if (file == INVALID_HANDLE_VALUE)
         {
-            const StringType message = fmt::format(STR("Failed to create crashdump file, reason: {:x}"), GetLastError());
+            const StringType message = fmt::format(STR("Failed to create crashdump file, reason: {}"), Win32Error(GetLastError()).c_str());
             MessageBoxW(NULL, FromCharTypePtr<wchar_t>(message.c_str()), L"Fatal Error!", MB_OK);
             return EXCEPTION_CONTINUE_SEARCH;
         }
@@ -56,7 +55,7 @@ namespace RC
 
         if (!ok)
         {
-            const StringType message = fmt::format(STR("Failed to write crashdump file, reason: {:x}"), GetLastError());
+            const StringType message = fmt::format(STR("Failed to write crashdump file, reason: {}"), Win32Error(GetLastError()).c_str());
             MessageBoxW(NULL, FromCharTypePtr<wchar_t>(message.c_str()), L"Fatal Error!", MB_OK);
             return EXCEPTION_CONTINUE_SEARCH;
         }
diff --git a/UE4SS/src/Mod/CppMod.cpp b/UE4SS/src/Mod/CppMod.cpp
@@ -1,13 +1,13 @@
 #define NOMINMAX
 
 #include <filesystem>
+#include <Windows.h>
 
 #include <DynamicOutput/DynamicOutput.hpp>
+#include <Helpers/Win32Error.hpp>
 #include <Helpers/String.hpp>
 #include <Mod/CppMod.hpp>
 
-#include <Windows.h>
-
 namespace RC
 {
     CppMod::CppMod(UE4SSProgram& program, StringType&& mod_name, StringType&& mod_path) : Mod(program, std::move(mod_name), std::move(mod_path))
@@ -28,7 +28,8 @@ namespace RC
 
         if (!m_main_dll_module)
         {
-            Output::send<LogLevel::Warning>(STR("Failed to load dll <{}> for mod {}, error code: 0x{:x}\n"), ensure_str(dll_path), m_mod_name, GetLastError());
+            Output::send<LogLevel::Warning>(STR("Failed to load dll <{}> for mod {}, error: {}\n"),
+                                            ensure_str(dll_path), m_mod_name, Win32Error(GetLastError()).c_str());
             set_installable(false);
             return;
         }
diff --git a/assets/Changelog.md b/assets/Changelog.md
@@ -45,6 +45,8 @@ Added override Lua files for ProcessLocalScriptFunction and ProcessInternal [UE4
 
 Added override Lua files for CallFunctionByNameWithArguments [UE4SS #848](https://github.com/UE4SS-RE/RE-UE4SS/pull/848) - M3C3I
 
+Add error messages in places where only error codes were previously logged (e.g. load a C++ mod) [UE4SS #902](https://github.com/UE4SS-RE/RE-UE4SS/pull/902) 
+
 ### Live View 
 Added search filter: `IncludeClassNames`. ([UE4SS #472](https://github.com/UE4SS-RE/RE-UE4SS/pull/472)) - Buckminsterfullerene
 
diff --git a/deps/first/File/src/FileType/WinFile.cpp b/deps/first/File/src/FileType/WinFile.cpp
@@ -6,6 +6,8 @@
 
 #define NOMINMAX
 #include <Windows.h>
+#include <Helpers/String.hpp>
+#include <Helpers/Win32Error.hpp>
 #ifdef TEXT
 #undef TEXT
 #endif
@@ -31,14 +33,16 @@ namespace RC::File
         {
             if (DeleteFileW(file_path_and_name.wstring().c_str()) == 0)
             {
-                THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::delete_file] Was unable to delete file, error: {}", GetLastError()))
+                THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::delete_file] Was unable to delete file, error: {}",
+                                                      to_string(Win32Error(GetLastError())).c_str()))
             }
         }
         else
         {
-            if (DeleteFileA(file_path_and_name.string().c_str()) != 0)
+            if (DeleteFileA(file_path_and_name.string().c_str()) == 0)
             {
-                THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::delete_file] Was unable to delete file, error: {}", GetLastError()))
+                THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::delete_file] Was unable to delete file, error: {}",
+                                                      to_string(Win32Error(GetLastError())).c_str()))
             }
         }
     }
@@ -70,7 +74,7 @@ namespace RC::File
 
     auto WinFile::get_raw_handle() noexcept -> void*
     {
-        return static_cast<void*>(m_file);
+        return m_file;
     }
 
     auto WinFile::get_file_path() const noexcept -> const std::filesystem::path&
@@ -99,7 +103,8 @@ namespace RC::File
         DWORD bytes_written{};
         if (!WriteFile(file.get_file(), data, num_bytes_to_write, &bytes_written, nullptr))
         {
-            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::write_to_file] Tried writing to file but was unable to complete operation. Error: {}", GetLastError()))
+            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::write_to_file] Tried writing to file but was unable to complete operation. error: {}",
+                                                  to_string(Win32Error(GetLastError())).c_str()))
         }
     }
 
@@ -168,10 +173,8 @@ namespace RC::File
             {
                 return false;
             }
-            else
-            {
-                deserialize_identifying_properties();
-            }
+
+            deserialize_identifying_properties();
         }
 
         BY_HANDLE_FILE_INFORMATION live_info{};
@@ -292,8 +295,8 @@ namespace RC::File
             auto res = ReadFile(cache_file.get_raw_handle(), &m_cache, cache_size, &bytes_read, nullptr);
             if (res == 0)
             {
-                THROW_INTERNAL_FILE_ERROR(
-                        fmt::format("[WinFile::get_serialized_item] Tried deserializing file but was unable to complete operation. Error: {}", GetLastError()))
+                THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::get_serialized_item] Tried deserializing file but was unable to complete operation. error: {}",
+                                                      to_string(Win32Error(GetLastError())).c_str()))
             }
 
             cache_file.close();
@@ -329,7 +332,7 @@ namespace RC::File
         }
         catch (const std::filesystem::filesystem_error& e)
         {
-            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::create_all_directories] Tried creating directories '{}' but encountered an error. Error: {}",
+            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::create_all_directories] Tried creating directories '{}' but encountered an error. error: {}",
                                                   file_name_and_path.string(),
                                                   e.what()))
         }
@@ -341,7 +344,7 @@ namespace RC::File
         {
             if (UnmapViewOfFile(m_memory_map) == 0)
             {
-                THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::close_file] Was unable to unmap file, error: {}", GetLastError()))
+                THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::close_file] Was unable to unmap file, error: {}", to_string(Win32Error(GetLastError())).c_str()))
             }
             else
             {
@@ -353,7 +356,7 @@ namespace RC::File
         {
             if (CloseHandle(m_map_handle) == 0)
             {
-                THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::close_file] Was unable to close map handle, error: {}", GetLastError()))
+                THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::close_file] Was unable to close map handle, {}", to_string(Win32Error(GetLastError())).c_str()))
             }
             else
             {
@@ -368,7 +371,7 @@ namespace RC::File
 
         if (CloseHandle(m_file) == 0)
         {
-            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::close_file] Was unable to close file, error: {}", GetLastError()))
+            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::close_file] Was unable to close file, {}", to_string(Win32Error(GetLastError())).c_str()))
         }
         else
         {
@@ -387,7 +390,8 @@ namespace RC::File
                 WideCharToMultiByte(CP_UTF8, 0, FromCharTypePtr<wchar_t>(string_to_write.data()), static_cast<int>(string_to_write.size()), NULL, 0, NULL, NULL);
         if (string_size == 0)
         {
-            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::write_string_to_file] Tried writing string to file but string_size was 0. Error: {}", GetLastError()))
+            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::write_string_to_file] Tried writing string to file but string_size was 0. {}",
+                                                  to_string(Win32Error(GetLastError())).c_str()))
         }
 
         std::string string_converted_to_utf8(string_size, 0);
@@ -401,7 +405,8 @@ namespace RC::File
                                 NULL) == 0)
         {
             THROW_INTERNAL_FILE_ERROR(
-                    fmt::format("[WinFile::write_string_to_file] Tried writing string to file but could not convert to utf-8. Error: {}", GetLastError()))
+                    fmt::format("[WinFile::write_string_to_file] Tried writing string to file but could not convert to utf-8. {}",
+                                to_string(Win32Error(GetLastError())).c_str()))
         }
 
         write_to_file(*this, string_converted_to_utf8.c_str(), string_size);
@@ -412,13 +417,13 @@ namespace RC::File
         BY_HANDLE_FILE_INFORMATION file_info{};
         if (GetFileInformationByHandle(m_file, &file_info) == 0)
         {
-            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::is_same_as] Tried retrieving file information by handle. Error: {}", GetLastError()))
+            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::is_same_as] Tried retrieving file information by handle. {}", to_string(Win32Error(GetLastError())).c_str()))
         }
 
         BY_HANDLE_FILE_INFORMATION other_file_info{};
         if (GetFileInformationByHandle(other_file.get_file(), &other_file_info) == 0)
         {
-            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::is_same_as] Tried retrieving file information by handle. Error: {}", GetLastError()))
+            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::is_same_as] Tried retrieving file information by handle. {}", to_string(Win32Error(GetLastError())).c_str()))
         }
 
         if (file_info.dwVolumeSerialNumber != other_file_info.dwVolumeSerialNumber)
@@ -496,8 +501,8 @@ namespace RC::File
 
     auto WinFile::memory_map() -> std::span<uint8_t>
     {
-        DWORD handle_desired_access{};
-        DWORD mapping_desired_access{};
+        DWORD handle_desired_access, mapping_desired_access;
+
         switch (m_open_properties.open_for)
         {
         case OpenFor::Writing:
@@ -517,13 +522,15 @@ namespace RC::File
         m_map_handle = CreateFileMapping(get_raw_handle(), nullptr, handle_desired_access, 0, 0, nullptr);
         if (!m_map_handle)
         {
-            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::memory_map] Tried to memory map file but 'CreateFileMapping' returned error: {}", GetLastError()))
+            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::memory_map] Tried to memory map file but 'CreateFileMapping' returned {}",
+                                      to_string(Win32Error(GetLastError())).c_str()))
         }
 
         m_memory_map = static_cast<uint8_t*>(MapViewOfFile(m_map_handle, mapping_desired_access, 0, 0, 0));
         if (!m_memory_map)
         {
-            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::memory_map] Tried to memory map file but 'MapViewOfFile' returned error: {}", GetLastError()))
+            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::memory_map] Tried to memory map file but 'MapViewOfFile' returned {}",
+                                      to_string(Win32Error(GetLastError())).c_str()))
         }
 
         MEMORY_BASIC_INFORMATION buffer{};
@@ -605,23 +612,8 @@ namespace RC::File
         {
             std::string_view open_type = open_properties.open_for == OpenFor::Writing || open_properties.open_for == OpenFor::Appending ? "writing" : "reading";
 
-            DWORD error = GetLastError();
-            if (error == 2)
-            {
-                throw FileNotFoundException{fmt::format("File not found: {}", file_name_and_path.filename().string())};
-            }
-            else if (error == 3)
-            {
-                throw FileNotFoundException{fmt::format("Path not found: {}", file_name_and_path.filename().string())};
-            }
-            else
-            {
-                THROW_INTERNAL_FILE_ERROR(
-                        fmt::format("[WinFile::open_file] Tried opening file for {} but encountered an error. Path & File: {} | GetLastError() = {}\n",
-                                    open_type,
-                                    file_name_and_path.string(),
-                                    error))
-            }
+            THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::open_file] Tried opening file for {} but encountered an error. Path & File: {} | error: {}\n",
+                                                  open_type, file_name_and_path.string(), to_string(Win32Error(GetLastError())).c_str()))
         }
 
         file.m_file_path_and_name = file_name_and_path;
diff --git a/deps/first/File/xmake.lua b/deps/first/File/xmake.lua
@@ -6,7 +6,7 @@ target(projectName)
     set_exceptions("cxx")
     add_rules("ue4ss.dependency")
     
-    add_deps("String")
+    add_deps("String", "Helpers")
 
     add_includedirs("include", { public = true }) 
     add_headerfiles("include/**.hpp")
diff --git a/deps/first/Helpers/include/Helpers/String.hpp b/deps/first/Helpers/include/Helpers/String.hpp
@@ -175,14 +175,20 @@ namespace RC
     }
     /* explode_by_occurrence -> END */
 
-    auto inline to_wstring(std::string& input) -> std::wstring
+    auto inline to_wstring(const std::string& input) -> std::wstring
     {
 #pragma warning(disable : 4996)
         static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter{};
         return converter.from_bytes(input);
 #pragma warning(default : 4996)
     }
 
+    auto inline to_wstring(const char* pInput)
+    {
+        auto temp_input = std::string{pInput};
+        return to_wstring(temp_input);
+    }
+
     auto inline to_wstring(std::string_view input) -> std::wstring
     {
 #ifdef PLATFORM_WINDOWS
@@ -208,12 +214,12 @@ namespace RC
         return std::wstring{input};
     }
 
-    auto inline to_wstring(std::wstring& input) -> std::wstring
+    auto inline to_wstring(const std::wstring& input) -> std::wstring
     {
         return std::wstring{input};
     }
 
-    auto inline to_wstring(std::u16string& input) -> std::wstring
+    auto inline to_wstring(const std::u16string& input) -> std::wstring
     {
 #ifdef PLATFORM_WINDOWS
         return {input.begin(), input.end()};
@@ -231,14 +237,20 @@ namespace RC
 #endif
     }
 
-    auto inline to_string(std::wstring& input) -> std::string
+    auto inline to_string(const std::wstring& input) -> std::string
     {
 #pragma warning(disable : 4996)
         static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter{};
         return converter.to_bytes(input);
 #pragma warning(default : 4996)
     }
 
+    auto inline to_string(const wchar_t* pInput)
+    {
+        auto temp_input = std::wstring{pInput};
+        return to_string(temp_input);
+    }
+
     auto inline to_string(std::wstring_view input) -> std::string
     {
         auto temp_input = std::wstring{input};
@@ -260,7 +272,7 @@ namespace RC
 #endif
     }
 
-    auto inline to_u16string(std::wstring& input) -> std::u16string
+    auto inline to_u16string(const std::wstring& input) -> std::u16string
     {
         return {input.begin(), input.end()};
     }
@@ -271,7 +283,7 @@ namespace RC
         return to_u16string(temp_input);
     }
 
-    auto inline to_u16string(std::string& input) -> std::u16string
+    auto inline to_u16string(const std::string& input) -> std::u16string
     {
         return {input.begin(), input.end()};
     }
diff --git a/deps/first/Helpers/include/Helpers/Win32Error.hpp b/deps/first/Helpers/include/Helpers/Win32Error.hpp
diff --git a/deps/first/Helpers/src/Win32Error.cpp b/deps/first/Helpers/src/Win32Error.cpp
diff --git a/deps/first/Unreal b/deps/first/Unreal

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,8 @@`
`6`	`6`
`7`	`7`	`#define NOMINMAX`
`8`	`8`	`#include <Windows.h>`
	`9`	`+#include <Helpers/String.hpp>`
	`10`	`+#include <Helpers/Win32Error.hpp>`
`9`	`11`	`#ifdef TEXT`
`10`	`12`	`#undef TEXT`
`11`	`13`	`#endif`
`@@ -31,14 +33,16 @@ namespace RC::File`
`31`	`33`	`{`
`32`	`34`	`if (DeleteFileW(file_path_and_name.wstring().c_str()) == 0)`
`33`	`35`	`{`
`34`		`- THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::delete_file] Was unable to delete file, error: {}", GetLastError()))`
	`36`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::delete_file] Was unable to delete file, error: {}",`
	`37`	`+ to_string(Win32Error(GetLastError())).c_str()))`
`35`	`38`	`}`
`36`	`39`	`}`
`37`	`40`	`else`
`38`	`41`	`{`
`39`		`- if (DeleteFileA(file_path_and_name.string().c_str()) != 0)`
	`42`	`+ if (DeleteFileA(file_path_and_name.string().c_str()) == 0)`
`40`	`43`	`{`
`41`		`- THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::delete_file] Was unable to delete file, error: {}", GetLastError()))`
	`44`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::delete_file] Was unable to delete file, error: {}",`
	`45`	`+ to_string(Win32Error(GetLastError())).c_str()))`
`42`	`46`	`}`
`43`	`47`	`}`
`44`	`48`	`}`
`@@ -70,7 +74,7 @@ namespace RC::File`
`70`	`74`
`71`	`75`	`auto WinFile::get_raw_handle() noexcept -> void*`
`72`	`76`	`{`
`73`		`- return static_cast<void*>(m_file);`
	`77`	`+ return m_file;`
`74`	`78`	`}`
`75`	`79`
`76`	`80`	`auto WinFile::get_file_path() const noexcept -> const std::filesystem::path&`
`@@ -99,7 +103,8 @@ namespace RC::File`
`99`	`103`	`DWORD bytes_written{};`
`100`	`104`	`if (!WriteFile(file.get_file(), data, num_bytes_to_write, &bytes_written, nullptr))`
`101`	`105`	`{`
`102`		`- THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::write_to_file] Tried writing to file but was unable to complete operation. Error: {}", GetLastError()))`
	`106`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::write_to_file] Tried writing to file but was unable to complete operation. error: {}",`
	`107`	`+ to_string(Win32Error(GetLastError())).c_str()))`
`103`	`108`	`}`
`104`	`109`	`}`
`105`	`110`
`@@ -168,10 +173,8 @@ namespace RC::File`
`168`	`173`	`{`
`169`	`174`	`return false;`
`170`	`175`	`}`
`171`		`- else`
`172`		`- {`
`173`		`- deserialize_identifying_properties();`
`174`		`- }`
	`176`	`+`
	`177`	`+ deserialize_identifying_properties();`
`175`	`178`	`}`
`176`	`179`
`177`	`180`	`BY_HANDLE_FILE_INFORMATION live_info{};`
`@@ -292,8 +295,8 @@ namespace RC::File`
`292`	`295`	`auto res = ReadFile(cache_file.get_raw_handle(), &m_cache, cache_size, &bytes_read, nullptr);`
`293`	`296`	`if (res == 0)`
`294`	`297`	`{`
`295`		`- THROW_INTERNAL_FILE_ERROR(`
`296`		`- fmt::format("[WinFile::get_serialized_item] Tried deserializing file but was unable to complete operation. Error: {}", GetLastError()))`
	`298`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::get_serialized_item] Tried deserializing file but was unable to complete operation. error: {}",`
	`299`	`+ to_string(Win32Error(GetLastError())).c_str()))`
`297`	`300`	`}`
`298`	`301`
`299`	`302`	`cache_file.close();`
`@@ -329,7 +332,7 @@ namespace RC::File`
`329`	`332`	`}`
`330`	`333`	`catch (const std::filesystem::filesystem_error& e)`
`331`	`334`	`{`
`332`		`- THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::create_all_directories] Tried creating directories '{}' but encountered an error. Error: {}",`
	`335`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::create_all_directories] Tried creating directories '{}' but encountered an error. error: {}",`
`333`	`336`	`file_name_and_path.string(),`
`334`	`337`	`e.what()))`
`335`	`338`	`}`
`@@ -341,7 +344,7 @@ namespace RC::File`
`341`	`344`	`{`
`342`	`345`	`if (UnmapViewOfFile(m_memory_map) == 0)`
`343`	`346`	`{`
`344`		`- THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::close_file] Was unable to unmap file, error: {}", GetLastError()))`
	`347`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::close_file] Was unable to unmap file, error: {}", to_string(Win32Error(GetLastError())).c_str()))`
`345`	`348`	`}`
`346`	`349`	`else`
`347`	`350`	`{`
`@@ -353,7 +356,7 @@ namespace RC::File`
`353`	`356`	`{`
`354`	`357`	`if (CloseHandle(m_map_handle) == 0)`
`355`	`358`	`{`
`356`		`- THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::close_file] Was unable to close map handle, error: {}", GetLastError()))`
	`359`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::close_file] Was unable to close map handle, {}", to_string(Win32Error(GetLastError())).c_str()))`
`357`	`360`	`}`
`358`	`361`	`else`
`359`	`362`	`{`
`@@ -368,7 +371,7 @@ namespace RC::File`
`368`	`371`
`369`	`372`	`if (CloseHandle(m_file) == 0)`
`370`	`373`	`{`
`371`		`- THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::close_file] Was unable to close file, error: {}", GetLastError()))`
	`374`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::close_file] Was unable to close file, {}", to_string(Win32Error(GetLastError())).c_str()))`
`372`	`375`	`}`
`373`	`376`	`else`
`374`	`377`	`{`
`@@ -387,7 +390,8 @@ namespace RC::File`
`387`	`390`	`WideCharToMultiByte(CP_UTF8, 0, FromCharTypePtr<wchar_t>(string_to_write.data()), static_cast<int>(string_to_write.size()), NULL, 0, NULL, NULL);`
`388`	`391`	`if (string_size == 0)`
`389`	`392`	`{`
`390`		`- THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::write_string_to_file] Tried writing string to file but string_size was 0. Error: {}", GetLastError()))`
	`393`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::write_string_to_file] Tried writing string to file but string_size was 0. {}",`
	`394`	`+ to_string(Win32Error(GetLastError())).c_str()))`
`391`	`395`	`}`
`392`	`396`
`393`	`397`	`std::string string_converted_to_utf8(string_size, 0);`
`@@ -401,7 +405,8 @@ namespace RC::File`
`401`	`405`	`NULL) == 0)`
`402`	`406`	`{`
`403`	`407`	`THROW_INTERNAL_FILE_ERROR(`
`404`		`- fmt::format("[WinFile::write_string_to_file] Tried writing string to file but could not convert to utf-8. Error: {}", GetLastError()))`
	`408`	`+ fmt::format("[WinFile::write_string_to_file] Tried writing string to file but could not convert to utf-8. {}",`
	`409`	`+ to_string(Win32Error(GetLastError())).c_str()))`
`405`	`410`	`}`
`406`	`411`
`407`	`412`	`write_to_file(*this, string_converted_to_utf8.c_str(), string_size);`
`@@ -412,13 +417,13 @@ namespace RC::File`
`412`	`417`	`BY_HANDLE_FILE_INFORMATION file_info{};`
`413`	`418`	`if (GetFileInformationByHandle(m_file, &file_info) == 0)`
`414`	`419`	`{`
`415`		`- THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::is_same_as] Tried retrieving file information by handle. Error: {}", GetLastError()))`
	`420`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::is_same_as] Tried retrieving file information by handle. {}", to_string(Win32Error(GetLastError())).c_str()))`
`416`	`421`	`}`
`417`	`422`
`418`	`423`	`BY_HANDLE_FILE_INFORMATION other_file_info{};`
`419`	`424`	`if (GetFileInformationByHandle(other_file.get_file(), &other_file_info) == 0)`
`420`	`425`	`{`
`421`		`- THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::is_same_as] Tried retrieving file information by handle. Error: {}", GetLastError()))`
	`426`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::is_same_as] Tried retrieving file information by handle. {}", to_string(Win32Error(GetLastError())).c_str()))`
`422`	`427`	`}`
`423`	`428`
`424`	`429`	`if (file_info.dwVolumeSerialNumber != other_file_info.dwVolumeSerialNumber)`
`@@ -496,8 +501,8 @@ namespace RC::File`
`496`	`501`
`497`	`502`	`auto WinFile::memory_map() -> std::span<uint8_t>`
`498`	`503`	`{`
`499`		`- DWORD handle_desired_access{};`
`500`		`- DWORD mapping_desired_access{};`
	`504`	`+ DWORD handle_desired_access, mapping_desired_access;`
	`505`	`+`
`501`	`506`	`switch (m_open_properties.open_for)`
`502`	`507`	`{`
`503`	`508`	`case OpenFor::Writing:`
`@@ -517,13 +522,15 @@ namespace RC::File`
`517`	`522`	`m_map_handle = CreateFileMapping(get_raw_handle(), nullptr, handle_desired_access, 0, 0, nullptr);`
`518`	`523`	`if (!m_map_handle)`
`519`	`524`	`{`
`520`		`- THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::memory_map] Tried to memory map file but 'CreateFileMapping' returned error: {}", GetLastError()))`
	`525`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::memory_map] Tried to memory map file but 'CreateFileMapping' returned {}",`
	`526`	`+ to_string(Win32Error(GetLastError())).c_str()))`
`521`	`527`	`}`
`522`	`528`
`523`	`529`	`m_memory_map = static_cast<uint8_t*>(MapViewOfFile(m_map_handle, mapping_desired_access, 0, 0, 0));`
`524`	`530`	`if (!m_memory_map)`
`525`	`531`	`{`
`526`		`- THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::memory_map] Tried to memory map file but 'MapViewOfFile' returned error: {}", GetLastError()))`
	`532`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::memory_map] Tried to memory map file but 'MapViewOfFile' returned {}",`
	`533`	`+ to_string(Win32Error(GetLastError())).c_str()))`
`527`	`534`	`}`
`528`	`535`
`529`	`536`	`MEMORY_BASIC_INFORMATION buffer{};`
`@@ -605,23 +612,8 @@ namespace RC::File`
`605`	`612`	`{`
`606`	`613`	`std::string_view open_type = open_properties.open_for == OpenFor::Writing \|\| open_properties.open_for == OpenFor::Appending ? "writing" : "reading";`
`607`	`614`
`608`		`- DWORD error = GetLastError();`
`609`		`- if (error == 2)`
`610`		`- {`
`611`		`- throw FileNotFoundException{fmt::format("File not found: {}", file_name_and_path.filename().string())};`
`612`		`- }`
`613`		`- else if (error == 3)`
`614`		`- {`
`615`		`- throw FileNotFoundException{fmt::format("Path not found: {}", file_name_and_path.filename().string())};`
`616`		`- }`
`617`		`- else`
`618`		`- {`
`619`		`- THROW_INTERNAL_FILE_ERROR(`
`620`		`- fmt::format("[WinFile::open_file] Tried opening file for {} but encountered an error. Path & File: {} \| GetLastError() = {}\n",`
`621`		`- open_type,`
`622`		`- file_name_and_path.string(),`
`623`		`- error))`
`624`		`- }`
	`615`	`+ THROW_INTERNAL_FILE_ERROR(fmt::format("[WinFile::open_file] Tried opening file for {} but encountered an error. Path & File: {} \| error: {}\n",`
	`616`	`+ open_type, file_name_and_path.string(), to_string(Win32Error(GetLastError())).c_str()))`
`625`	`617`	`}`
`626`	`618`
`627`	`619`	`file.m_file_path_and_name = file_name_and_path;`
Original file line number	Diff line number	Diff line change
`@@ -175,14 +175,20 @@ namespace RC`
`175`	`175`	`}`
`176`	`176`	`/* explode_by_occurrence -> END */`
`177`	`177`
`178`		`- auto inline to_wstring(std::string& input) -> std::wstring`
	`178`	`+ auto inline to_wstring(const std::string& input) -> std::wstring`
`179`	`179`	`{`
`180`	`180`	`#pragma warning(disable : 4996)`
`181`	`181`	`static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter{};`
`182`	`182`	`return converter.from_bytes(input);`
`183`	`183`	`#pragma warning(default : 4996)`
`184`	`184`	`}`
`185`	`185`
	`186`	`+ auto inline to_wstring(const char* pInput)`
	`187`	`+ {`
	`188`	`+ auto temp_input = std::string{pInput};`
	`189`	`+ return to_wstring(temp_input);`
	`190`	`+ }`
	`191`	`+`
`186`	`192`	`auto inline to_wstring(std::string_view input) -> std::wstring`
`187`	`193`	`{`
`188`	`194`	`#ifdef PLATFORM_WINDOWS`
`@@ -208,12 +214,12 @@ namespace RC`
`208`	`214`	`return std::wstring{input};`
`209`	`215`	`}`
`210`	`216`
`211`		`- auto inline to_wstring(std::wstring& input) -> std::wstring`
	`217`	`+ auto inline to_wstring(const std::wstring& input) -> std::wstring`
`212`	`218`	`{`
`213`	`219`	`return std::wstring{input};`
`214`	`220`	`}`
`215`	`221`
`216`		`- auto inline to_wstring(std::u16string& input) -> std::wstring`
	`222`	`+ auto inline to_wstring(const std::u16string& input) -> std::wstring`
`217`	`223`	`{`
`218`	`224`	`#ifdef PLATFORM_WINDOWS`
`219`	`225`	`return {input.begin(), input.end()};`
`@@ -231,14 +237,20 @@ namespace RC`
`231`	`237`	`#endif`
`232`	`238`	`}`
`233`	`239`
`234`		`- auto inline to_string(std::wstring& input) -> std::string`
	`240`	`+ auto inline to_string(const std::wstring& input) -> std::string`
`235`	`241`	`{`
`236`	`242`	`#pragma warning(disable : 4996)`
`237`	`243`	`static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter{};`
`238`	`244`	`return converter.to_bytes(input);`
`239`	`245`	`#pragma warning(default : 4996)`
`240`	`246`	`}`
`241`	`247`
	`248`	`+ auto inline to_string(const wchar_t* pInput)`
	`249`	`+ {`
	`250`	`+ auto temp_input = std::wstring{pInput};`
	`251`	`+ return to_string(temp_input);`
	`252`	`+ }`
	`253`	`+`
`242`	`254`	`auto inline to_string(std::wstring_view input) -> std::string`
`243`	`255`	`{`
`244`	`256`	`auto temp_input = std::wstring{input};`
`@@ -260,7 +272,7 @@ namespace RC`
`260`	`272`	`#endif`
`261`	`273`	`}`
`262`	`274`
`263`		`- auto inline to_u16string(std::wstring& input) -> std::u16string`
	`275`	`+ auto inline to_u16string(const std::wstring& input) -> std::u16string`
`264`	`276`	`{`
`265`	`277`	`return {input.begin(), input.end()};`
`266`	`278`	`}`
`@@ -271,7 +283,7 @@ namespace RC`
`271`	`283`	`return to_u16string(temp_input);`
`272`	`284`	`}`
`273`	`285`
`274`		`- auto inline to_u16string(std::string& input) -> std::u16string`
	`286`	`+ auto inline to_u16string(const std::string& input) -> std::u16string`
`275`	`287`	`{`
`276`	`288`	`return {input.begin(), input.end()};`
`277`	`289`	`}`