common: fs: Initial port of yuzu fs library
This commit is contained in:
GPUCode
@ -69,9 +69,20 @@ add_library(common STATIC
|
|||||||
common_funcs.h
|
common_funcs.h
|
||||||
common_paths.h
|
common_paths.h
|
||||||
common_types.h
|
common_types.h
|
||||||
|
concepts.h
|
||||||
construct.h
|
construct.h
|
||||||
file_util.cpp
|
#file_util.cpp
|
||||||
file_util.h
|
#file_util.h
|
||||||
|
fs/file.cpp
|
||||||
|
fs/file.h
|
||||||
|
fs/fs.cpp
|
||||||
|
fs/fs.h
|
||||||
|
fs/fs_paths.h
|
||||||
|
fs/fs_types.h
|
||||||
|
fs/fs_util.cpp
|
||||||
|
fs/fs_util.h
|
||||||
|
fs/path_util.cpp
|
||||||
|
fs/path_util.h
|
||||||
hash.h
|
hash.h
|
||||||
linear_disk_cache.h
|
linear_disk_cache.h
|
||||||
logging/backend.cpp
|
logging/backend.cpp
|
||||||
|
|||||||
35
src/common/concepts.h
Normal file
35
src/common/concepts.h
Normal file
@ -0,0 +1,35 @@
|
|||||||
|
// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <iterator>
|
||||||
|
#include <type_traits>
|
||||||
|
|
||||||
|
namespace Common {
|
||||||
|
|
||||||
|
// Check if type satisfies the ContiguousContainer named requirement.
|
||||||
|
template <typename T>
|
||||||
|
concept IsContiguousContainer = std::contiguous_iterator<typename T::iterator>;
|
||||||
|
|
||||||
|
// TODO: Replace with std::derived_from when the <concepts> header
|
||||||
|
// is available on all supported platforms.
|
||||||
|
template <typename Derived, typename Base>
|
||||||
|
concept DerivedFrom = requires {
|
||||||
|
std::is_base_of_v<Base, Derived>;
|
||||||
|
std::is_convertible_v<const volatile Derived*, const volatile Base*>;
|
||||||
|
};
|
||||||
|
|
||||||
|
// TODO: Replace with std::convertible_to when libc++ implements it.
|
||||||
|
template <typename From, typename To>
|
||||||
|
concept ConvertibleTo = std::is_convertible_v<From, To>;
|
||||||
|
|
||||||
|
// No equivalents in the stdlib
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
concept IsArithmetic = std::is_arithmetic_v<T>;
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
concept IsIntegral = std::is_integral_v<T>;
|
||||||
|
|
||||||
|
} // namespace Common
|
||||||
@ -1,854 +0,0 @@
|
|||||||
// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
|
|
||||||
// Licensed under GPLv2 or any later version
|
|
||||||
// Refer to the license.txt file included.
|
|
||||||
|
|
||||||
#include <array>
|
|
||||||
#include <filesystem>
|
|
||||||
#include <limits>
|
|
||||||
#include <memory>
|
|
||||||
#include <sstream>
|
|
||||||
#include <unordered_map>
|
|
||||||
#include "common/assert.h"
|
|
||||||
#include "common/common_funcs.h"
|
|
||||||
#include "common/common_paths.h"
|
|
||||||
#include "common/file_util.h"
|
|
||||||
#include "common/logging/log.h"
|
|
||||||
|
|
||||||
#ifdef _WIN32
|
|
||||||
#include <windows.h>
|
|
||||||
// windows.h needs to be included before other windows headers
|
|
||||||
#include <direct.h> // getcwd
|
|
||||||
#include <io.h>
|
|
||||||
#include <shellapi.h>
|
|
||||||
#include <shlobj.h> // for SHGetFolderPath
|
|
||||||
#include <tchar.h>
|
|
||||||
#include "common/string_util.h"
|
|
||||||
|
|
||||||
#ifdef _MSC_VER
|
|
||||||
// 64 bit offsets for MSVC
|
|
||||||
#define fseeko _fseeki64
|
|
||||||
#define ftello _ftelli64
|
|
||||||
#define fileno _fileno
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// 64 bit offsets for MSVC and MinGW. MinGW also needs this for using _wstat64
|
|
||||||
#ifndef __MINGW64__
|
|
||||||
#define stat _stat64
|
|
||||||
#define fstat _fstat64
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#else
|
|
||||||
#ifdef __APPLE__
|
|
||||||
#include <sys/param.h>
|
|
||||||
#endif
|
|
||||||
#include <cctype>
|
|
||||||
#include <cerrno>
|
|
||||||
#include <cstdlib>
|
|
||||||
#include <cstring>
|
|
||||||
#include <dirent.h>
|
|
||||||
#include <pwd.h>
|
|
||||||
#include <unistd.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(__APPLE__)
|
|
||||||
// CFURL contains __attribute__ directives that gcc does not know how to parse, so we need to just
|
|
||||||
// ignore them if we're not using clang. The macro is only used to prevent linking against
|
|
||||||
// functions that don't exist on older versions of macOS, and the worst case scenario is a linker
|
|
||||||
// error, so this is perfectly safe, just inconvenient.
|
|
||||||
#ifndef __clang__
|
|
||||||
#define availability(...)
|
|
||||||
#endif
|
|
||||||
#include <CoreFoundation/CFBundle.h>
|
|
||||||
#include <CoreFoundation/CFString.h>
|
|
||||||
#include <CoreFoundation/CFURL.h>
|
|
||||||
#ifdef availability
|
|
||||||
#undef availability
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include <algorithm>
|
|
||||||
#include <sys/stat.h>
|
|
||||||
|
|
||||||
namespace Common::FS {
|
|
||||||
namespace fs = std::filesystem;
|
|
||||||
|
|
||||||
bool Exists(const fs::path& path) {
|
|
||||||
std::error_code ec;
|
|
||||||
return fs::exists(path, ec);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool IsDirectory(const fs::path& path) {
|
|
||||||
std::error_code ec;
|
|
||||||
return fs::is_directory(path, ec);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool Delete(const fs::path& path) {
|
|
||||||
LOG_TRACE(Common_Filesystem, "file {}", path.string());
|
|
||||||
|
|
||||||
// Return true because we care about the file no
|
|
||||||
// being there, not the actual delete.
|
|
||||||
if (!Exists(path)) {
|
|
||||||
LOG_DEBUG(Common_Filesystem, "{} does not exist", path.string());
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::error_code ec;
|
|
||||||
return fs::remove(path, ec);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool CreateDir(const fs::path& path) {
|
|
||||||
LOG_TRACE(Common_Filesystem, "directory {}", path.string());
|
|
||||||
|
|
||||||
std::error_code ec;
|
|
||||||
const bool success = fs::create_directory(path, ec);
|
|
||||||
|
|
||||||
if (!success) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "Unable to create directory: {}", ec.message());
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool CreateFullPath(const fs::path& path) {
|
|
||||||
LOG_TRACE(Common_Filesystem, "path {}", path.string());
|
|
||||||
|
|
||||||
std::error_code ec;
|
|
||||||
const bool success = fs::create_directories(path, ec);
|
|
||||||
|
|
||||||
if (!success) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "Unable to create full path: {}", ec.message());
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool Rename(const fs::path& src, const fs::path& dst) {
|
|
||||||
LOG_TRACE(Common_Filesystem, "{} --> {}", src.string(), dst.string());
|
|
||||||
|
|
||||||
std::error_code ec;
|
|
||||||
fs::rename(src, dst, ec);
|
|
||||||
|
|
||||||
if (ec) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "Unable to rename file from {} to {}: {}", src.string(),
|
|
||||||
dst.string(), ec.message());
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool Copy(const fs::path& src, const fs::path& dst) {
|
|
||||||
LOG_TRACE(Common_Filesystem, "{} --> {}", src.string(), dst.string());
|
|
||||||
|
|
||||||
std::error_code ec;
|
|
||||||
const bool success = fs::copy_file(src, dst, fs::copy_options::overwrite_existing, ec);
|
|
||||||
|
|
||||||
if (!success) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "Unable to copy file {} to {}: {}", src.string(), dst.string(),
|
|
||||||
ec.message());
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
u64 GetSize(const fs::path& path) {
|
|
||||||
std::error_code ec;
|
|
||||||
const auto size = fs::file_size(path, ec);
|
|
||||||
|
|
||||||
if (ec) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "Unable to retrieve file size ({}): {}", path.string(),
|
|
||||||
ec.message());
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
return size;
|
|
||||||
}
|
|
||||||
|
|
||||||
u64 GetSize(FILE* f) {
|
|
||||||
// can't use off_t here because it can be 32-bit
|
|
||||||
u64 pos = ftello(f);
|
|
||||||
if (fseeko(f, 0, SEEK_END) != 0) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f), GetLastErrorMsg());
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
u64 size = ftello(f);
|
|
||||||
if ((size != pos) && (fseeko(f, pos, SEEK_SET) != 0)) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "GetSize: seek failed {}: {}", fmt::ptr(f), GetLastErrorMsg());
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
return size;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool CreateEmptyFile(const std::string& filename) {
|
|
||||||
LOG_TRACE(Common_Filesystem, "{}", filename);
|
|
||||||
|
|
||||||
if (!IOFile(filename, "wb").IsOpen()) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "failed {}: {}", filename, GetLastErrorMsg());
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
|
|
||||||
DirectoryEntryCallable callback) {
|
|
||||||
LOG_TRACE(Common_Filesystem, "directory {}", directory);
|
|
||||||
|
|
||||||
// How many files + directories we found
|
|
||||||
u64 found_entries = 0;
|
|
||||||
|
|
||||||
// Save the status of callback function
|
|
||||||
bool callback_error = false;
|
|
||||||
|
|
||||||
#ifdef _WIN32
|
|
||||||
// Find the first file in the directory.
|
|
||||||
WIN32_FIND_DATAW ffd;
|
|
||||||
|
|
||||||
HANDLE handle_find = FindFirstFileW(Common::UTF8ToUTF16W(directory + "\\*").c_str(), &ffd);
|
|
||||||
if (handle_find == INVALID_HANDLE_VALUE) {
|
|
||||||
FindClose(handle_find);
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
// windows loop
|
|
||||||
do {
|
|
||||||
const std::string virtual_name(Common::UTF16ToUTF8(ffd.cFileName));
|
|
||||||
#else
|
|
||||||
DIR* dirp = opendir(directory.c_str());
|
|
||||||
if (!dirp)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// non windows loop
|
|
||||||
while (struct dirent* result = readdir(dirp)) {
|
|
||||||
const std::string virtual_name(result->d_name);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
if (virtual_name == "." || virtual_name == "..")
|
|
||||||
continue;
|
|
||||||
|
|
||||||
u64 ret_entries = 0;
|
|
||||||
if (!callback(&ret_entries, directory, virtual_name)) {
|
|
||||||
callback_error = true;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
found_entries += ret_entries;
|
|
||||||
|
|
||||||
#ifdef _WIN32
|
|
||||||
} while (FindNextFileW(handle_find, &ffd) != 0);
|
|
||||||
FindClose(handle_find);
|
|
||||||
#else
|
|
||||||
}
|
|
||||||
closedir(dirp);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
if (callback_error)
|
|
||||||
return false;
|
|
||||||
|
|
||||||
// num_entries_out is allowed to be specified nullptr, in which case we shouldn't try to set it
|
|
||||||
if (num_entries_out != nullptr)
|
|
||||||
*num_entries_out = found_entries;
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
|
|
||||||
unsigned int recursion) {
|
|
||||||
const auto callback = [recursion, &parent_entry](u64* num_entries_out,
|
|
||||||
const std::string& directory,
|
|
||||||
const std::string& virtual_name) -> bool {
|
|
||||||
FSTEntry entry;
|
|
||||||
entry.virtualName = virtual_name;
|
|
||||||
entry.physicalName = directory + DIR_SEP + virtual_name;
|
|
||||||
|
|
||||||
if (IsDirectory(entry.physicalName)) {
|
|
||||||
entry.isDirectory = true;
|
|
||||||
// is a directory, lets go inside if we didn't recurse to often
|
|
||||||
if (recursion > 0) {
|
|
||||||
entry.size = ScanDirectoryTree(entry.physicalName, entry, recursion - 1);
|
|
||||||
*num_entries_out += entry.size;
|
|
||||||
} else {
|
|
||||||
entry.size = 0;
|
|
||||||
}
|
|
||||||
} else { // is a file
|
|
||||||
entry.isDirectory = false;
|
|
||||||
entry.size = GetSize(entry.physicalName);
|
|
||||||
}
|
|
||||||
(*num_entries_out)++;
|
|
||||||
|
|
||||||
// Push into the tree
|
|
||||||
parent_entry.children.push_back(std::move(entry));
|
|
||||||
return true;
|
|
||||||
};
|
|
||||||
|
|
||||||
u64 num_entries;
|
|
||||||
return ForeachDirectoryEntry(&num_entries, directory, callback) ? num_entries : 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
void GetAllFilesFromNestedEntries(FSTEntry& directory, std::vector<FSTEntry>& output) {
|
|
||||||
std::vector<FSTEntry> files;
|
|
||||||
for (auto& entry : directory.children) {
|
|
||||||
if (entry.isDirectory) {
|
|
||||||
GetAllFilesFromNestedEntries(entry, output);
|
|
||||||
} else {
|
|
||||||
output.push_back(entry);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
bool DeleteDirRecursively(const fs::path& path) {
|
|
||||||
std::error_code ec;
|
|
||||||
fs::remove_all(path, ec);
|
|
||||||
|
|
||||||
if (ec) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "Unable to completely delete directory {}: {}", path.string(),
|
|
||||||
ec.message());
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
void CopyDir(const fs::path& src, const fs::path& dst) {
|
|
||||||
constexpr auto copy_flags = fs::copy_options::skip_existing | fs::copy_options::recursive;
|
|
||||||
|
|
||||||
std::error_code ec;
|
|
||||||
fs::copy(src, dst, copy_flags, ec);
|
|
||||||
|
|
||||||
if (ec) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "Error copying directory {} to {}: {}", src.string(),
|
|
||||||
dst.string(), ec.message());
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
LOG_TRACE(Common_Filesystem, "Successfully copied directory.");
|
|
||||||
}
|
|
||||||
|
|
||||||
std::optional<fs::path> GetCurrentDir() {
|
|
||||||
std::error_code ec;
|
|
||||||
auto path = fs::current_path(ec);
|
|
||||||
|
|
||||||
if (ec) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "Unable to retrieve current working directory: {}",
|
|
||||||
ec.message());
|
|
||||||
return std::nullopt;
|
|
||||||
}
|
|
||||||
|
|
||||||
return {std::move(path)};
|
|
||||||
}
|
|
||||||
|
|
||||||
bool SetCurrentDir(const fs::path& path) {
|
|
||||||
std::error_code ec;
|
|
||||||
fs::current_path(path, ec);
|
|
||||||
|
|
||||||
if (ec) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "Unable to set {} as working directory: {}", path.string(),
|
|
||||||
ec.message());
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
#if defined(__APPLE__)
|
|
||||||
std::string GetBundleDirectory() {
|
|
||||||
CFURLRef BundleRef;
|
|
||||||
char AppBundlePath[MAXPATHLEN];
|
|
||||||
// Get the main bundle for the app
|
|
||||||
BundleRef = CFBundleCopyBundleURL(CFBundleGetMainBundle());
|
|
||||||
CFStringRef BundlePath = CFURLCopyFileSystemPath(BundleRef, kCFURLPOSIXPathStyle);
|
|
||||||
CFStringGetFileSystemRepresentation(BundlePath, AppBundlePath, sizeof(AppBundlePath));
|
|
||||||
CFRelease(BundleRef);
|
|
||||||
CFRelease(BundlePath);
|
|
||||||
|
|
||||||
return AppBundlePath;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef _WIN32
|
|
||||||
const std::string& GetExeDirectory() {
|
|
||||||
static std::string exe_path;
|
|
||||||
if (exe_path.empty()) {
|
|
||||||
wchar_t wchar_exe_path[2048];
|
|
||||||
GetModuleFileNameW(nullptr, wchar_exe_path, 2048);
|
|
||||||
exe_path = Common::UTF16ToUTF8(wchar_exe_path);
|
|
||||||
exe_path = exe_path.substr(0, exe_path.find_last_of('\\'));
|
|
||||||
}
|
|
||||||
return exe_path;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string AppDataRoamingDirectory() {
|
|
||||||
PWSTR pw_local_path = nullptr;
|
|
||||||
// Only supported by Windows Vista or later
|
|
||||||
SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, nullptr, &pw_local_path);
|
|
||||||
std::string local_path = Common::UTF16ToUTF8(pw_local_path);
|
|
||||||
CoTaskMemFree(pw_local_path);
|
|
||||||
return local_path;
|
|
||||||
}
|
|
||||||
#else
|
|
||||||
/**
|
|
||||||
* @return The user’s home directory on POSIX systems
|
|
||||||
*/
|
|
||||||
static const std::string& GetHomeDirectory() {
|
|
||||||
static std::string home_path;
|
|
||||||
if (home_path.empty()) {
|
|
||||||
const char* envvar = getenv("HOME");
|
|
||||||
if (envvar) {
|
|
||||||
home_path = envvar;
|
|
||||||
} else {
|
|
||||||
auto pw = getpwuid(getuid());
|
|
||||||
ASSERT_MSG(pw,
|
|
||||||
"$HOME isn’t defined, and the current user can’t be found in /etc/passwd.");
|
|
||||||
home_path = pw->pw_dir;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return home_path;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Follows the XDG Base Directory Specification to get a directory path
|
|
||||||
* @param envvar The XDG environment variable to get the value from
|
|
||||||
* @return The directory path
|
|
||||||
* @sa http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
|
|
||||||
*/
|
|
||||||
static const std::string GetUserDirectory(const std::string& envvar) {
|
|
||||||
const char* directory = getenv(envvar.c_str());
|
|
||||||
|
|
||||||
std::string user_dir;
|
|
||||||
if (directory) {
|
|
||||||
user_dir = directory;
|
|
||||||
} else {
|
|
||||||
std::string subdirectory;
|
|
||||||
if (envvar == "XDG_DATA_HOME")
|
|
||||||
subdirectory = DIR_SEP ".local" DIR_SEP "share";
|
|
||||||
else if (envvar == "XDG_CONFIG_HOME")
|
|
||||||
subdirectory = DIR_SEP ".config";
|
|
||||||
else if (envvar == "XDG_CACHE_HOME")
|
|
||||||
subdirectory = DIR_SEP ".cache";
|
|
||||||
else
|
|
||||||
ASSERT_MSG(false, "Unknown XDG variable {}.", envvar);
|
|
||||||
user_dir = GetHomeDirectory() + subdirectory;
|
|
||||||
}
|
|
||||||
|
|
||||||
ASSERT_MSG(!user_dir.empty(), "User directory {} musn’t be empty.", envvar);
|
|
||||||
ASSERT_MSG(user_dir[0] == '/', "User directory {} must be absolute.", envvar);
|
|
||||||
|
|
||||||
return user_dir;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
std::string GetSysDirectory() {
|
|
||||||
std::string sysDir;
|
|
||||||
|
|
||||||
#if defined(__APPLE__)
|
|
||||||
sysDir = GetBundleDirectory();
|
|
||||||
sysDir += DIR_SEP;
|
|
||||||
sysDir += SYSDATA_DIR;
|
|
||||||
#else
|
|
||||||
sysDir = SYSDATA_DIR;
|
|
||||||
#endif
|
|
||||||
sysDir += DIR_SEP;
|
|
||||||
|
|
||||||
LOG_DEBUG(Common_Filesystem, "Setting to {}:", sysDir);
|
|
||||||
return sysDir;
|
|
||||||
}
|
|
||||||
|
|
||||||
namespace {
|
|
||||||
std::unordered_map<UserPath, std::string> g_paths;
|
|
||||||
std::unordered_map<UserPath, std::string> g_default_paths;
|
|
||||||
} // namespace
|
|
||||||
|
|
||||||
void SetUserPath(const std::string& path) {
|
|
||||||
std::string& user_path = g_paths[UserPath::UserDir];
|
|
||||||
|
|
||||||
if (!path.empty() && CreateFullPath(path)) {
|
|
||||||
LOG_INFO(Common_Filesystem, "Using {} as the user directory", path);
|
|
||||||
user_path = path;
|
|
||||||
g_paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP);
|
|
||||||
} else {
|
|
||||||
#ifdef _WIN32
|
|
||||||
user_path = GetExeDirectory() + DIR_SEP USERDATA_DIR DIR_SEP;
|
|
||||||
if (!Common::FS::IsDirectory(user_path)) {
|
|
||||||
user_path = AppDataRoamingDirectory() + DIR_SEP EMU_DATA_DIR DIR_SEP;
|
|
||||||
} else {
|
|
||||||
LOG_INFO(Common_Filesystem, "Using the local user directory");
|
|
||||||
}
|
|
||||||
|
|
||||||
g_paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP);
|
|
||||||
#elif ANDROID
|
|
||||||
if (Common::FS::Exists(DIR_SEP SDCARD_DIR)) {
|
|
||||||
user_path = DIR_SEP SDCARD_DIR DIR_SEP EMU_DATA_DIR DIR_SEP;
|
|
||||||
g_paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP);
|
|
||||||
}
|
|
||||||
#else
|
|
||||||
if (Common::FS::Exists(ROOT_DIR DIR_SEP USERDATA_DIR)) {
|
|
||||||
user_path = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
|
|
||||||
g_paths.emplace(UserPath::ConfigDir, user_path + CONFIG_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::CacheDir, user_path + CACHE_DIR DIR_SEP);
|
|
||||||
} else {
|
|
||||||
std::string data_dir = GetUserDirectory("XDG_DATA_HOME");
|
|
||||||
std::string config_dir = GetUserDirectory("XDG_CONFIG_HOME");
|
|
||||||
std::string cache_dir = GetUserDirectory("XDG_CACHE_HOME");
|
|
||||||
|
|
||||||
user_path = data_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
|
|
||||||
g_paths.emplace(UserPath::ConfigDir, config_dir + DIR_SEP EMU_DATA_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::CacheDir, cache_dir + DIR_SEP EMU_DATA_DIR DIR_SEP);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
g_paths.emplace(UserPath::SDMCDir, user_path + SDMC_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::NANDDir, user_path + NAND_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::SysDataDir, user_path + SYSDATA_DIR DIR_SEP);
|
|
||||||
// TODO: Put the logs in a better location for each OS
|
|
||||||
g_paths.emplace(UserPath::LogDir, user_path + LOG_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::CheatsDir, user_path + CHEATS_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::DLLDir, user_path + DLL_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::ShaderDir, user_path + SHADER_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::DumpDir, user_path + DUMP_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::LoadDir, user_path + LOAD_DIR DIR_SEP);
|
|
||||||
g_paths.emplace(UserPath::StatesDir, user_path + STATES_DIR DIR_SEP);
|
|
||||||
g_default_paths = g_paths;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string g_currentRomPath{};
|
|
||||||
|
|
||||||
void SetCurrentRomPath(const std::string& path) {
|
|
||||||
g_currentRomPath = path;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool StringReplace(std::string& haystack, const std::string& a, const std::string& b, bool swap) {
|
|
||||||
const auto& needle = swap ? b : a;
|
|
||||||
const auto& replacement = swap ? a : b;
|
|
||||||
if (needle.empty()) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
auto index = haystack.find(needle, 0);
|
|
||||||
if (index == std::string::npos) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
haystack.replace(index, needle.size(), replacement);
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string SerializePath(const std::string& input, bool is_saving) {
|
|
||||||
auto result = input;
|
|
||||||
StringReplace(result, "%CITRA_ROM_FILE%", g_currentRomPath, is_saving);
|
|
||||||
StringReplace(result, "%CITRA_USER_DIR%", GetUserPath(UserPath::UserDir), is_saving);
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
const std::string& GetUserPath(UserPath path) {
|
|
||||||
// Set up all paths and files on the first run
|
|
||||||
if (g_paths.empty())
|
|
||||||
SetUserPath();
|
|
||||||
return g_paths[path];
|
|
||||||
}
|
|
||||||
|
|
||||||
const std::string& GetDefaultUserPath(UserPath path) {
|
|
||||||
// Set up all paths and files on the first run
|
|
||||||
if (g_default_paths.empty())
|
|
||||||
SetUserPath();
|
|
||||||
return g_default_paths[path];
|
|
||||||
}
|
|
||||||
|
|
||||||
const void UpdateUserPath(UserPath path, const std::string& filename) {
|
|
||||||
if (filename.empty()) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
if (!Common::FS::IsDirectory(filename)) {
|
|
||||||
LOG_ERROR(Common_Filesystem, "Path is not a directory. UserPath: {} filename: {}", path,
|
|
||||||
filename);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
g_paths[path] = SanitizePath(filename) + DIR_SEP;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::size_t WriteStringToFile(bool text_file, const std::string& filename, std::string_view str) {
|
|
||||||
return IOFile(filename, text_file ? "w" : "wb").WriteString(str);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::size_t ReadFileToString(bool text_file, const std::string& filename, std::string& str) {
|
|
||||||
IOFile file(filename, text_file ? "r" : "rb");
|
|
||||||
|
|
||||||
if (!file.IsOpen())
|
|
||||||
return 0;
|
|
||||||
|
|
||||||
str.resize(static_cast<u32>(file.GetSize()));
|
|
||||||
return file.ReadArray(str.data(), str.size());
|
|
||||||
}
|
|
||||||
|
|
||||||
void SplitFilename83(const std::string& filename, std::array<char, 9>& short_name,
|
|
||||||
std::array<char, 4>& extension) {
|
|
||||||
const std::string forbidden_characters = ".\"/\\[]:;=, ";
|
|
||||||
|
|
||||||
// On a FAT32 partition, 8.3 names are stored as a 11 bytes array, filled with spaces.
|
|
||||||
short_name = {{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\0'}};
|
|
||||||
extension = {{' ', ' ', ' ', '\0'}};
|
|
||||||
|
|
||||||
std::string::size_type point = filename.rfind('.');
|
|
||||||
if (point == filename.size() - 1)
|
|
||||||
point = filename.rfind('.', point);
|
|
||||||
|
|
||||||
// Get short name.
|
|
||||||
int j = 0;
|
|
||||||
for (char letter : filename.substr(0, point)) {
|
|
||||||
if (forbidden_characters.find(letter, 0) != std::string::npos)
|
|
||||||
continue;
|
|
||||||
if (j == 8) {
|
|
||||||
// TODO(Link Mauve): also do that for filenames containing a space.
|
|
||||||
// TODO(Link Mauve): handle multiple files having the same short name.
|
|
||||||
short_name[6] = '~';
|
|
||||||
short_name[7] = '1';
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
short_name[j++] = toupper(letter);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Get extension.
|
|
||||||
if (point != std::string::npos) {
|
|
||||||
j = 0;
|
|
||||||
for (char letter : filename.substr(point + 1, 3))
|
|
||||||
extension[j++] = toupper(letter);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
std::vector<std::string> SplitPathComponents(std::string_view filename) {
|
|
||||||
std::string copy(filename);
|
|
||||||
std::replace(copy.begin(), copy.end(), '\\', '/');
|
|
||||||
std::vector<std::string> out;
|
|
||||||
|
|
||||||
std::stringstream stream(copy);
|
|
||||||
std::string item;
|
|
||||||
while (std::getline(stream, item, '/')) {
|
|
||||||
out.push_back(std::move(item));
|
|
||||||
}
|
|
||||||
|
|
||||||
return out;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string_view GetParentPath(std::string_view path) {
|
|
||||||
const auto name_bck_index = path.rfind('\\');
|
|
||||||
const auto name_fwd_index = path.rfind('/');
|
|
||||||
std::size_t name_index;
|
|
||||||
|
|
||||||
if (name_bck_index == std::string_view::npos || name_fwd_index == std::string_view::npos) {
|
|
||||||
name_index = std::min(name_bck_index, name_fwd_index);
|
|
||||||
} else {
|
|
||||||
name_index = std::max(name_bck_index, name_fwd_index);
|
|
||||||
}
|
|
||||||
|
|
||||||
return path.substr(0, name_index);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string_view GetPathWithoutTop(std::string_view path) {
|
|
||||||
if (path.empty()) {
|
|
||||||
return path;
|
|
||||||
}
|
|
||||||
|
|
||||||
while (path[0] == '\\' || path[0] == '/') {
|
|
||||||
path.remove_prefix(1);
|
|
||||||
if (path.empty()) {
|
|
||||||
return path;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
const auto name_bck_index = path.find('\\');
|
|
||||||
const auto name_fwd_index = path.find('/');
|
|
||||||
return path.substr(std::min(name_bck_index, name_fwd_index) + 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string_view GetFilename(std::string_view path) {
|
|
||||||
const auto name_index = path.find_last_of("\\/");
|
|
||||||
|
|
||||||
if (name_index == std::string_view::npos) {
|
|
||||||
return {};
|
|
||||||
}
|
|
||||||
|
|
||||||
return path.substr(name_index + 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string_view GetExtensionFromFilename(std::string_view name) {
|
|
||||||
const std::size_t index = name.rfind('.');
|
|
||||||
|
|
||||||
if (index == std::string_view::npos) {
|
|
||||||
return {};
|
|
||||||
}
|
|
||||||
|
|
||||||
return name.substr(index + 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string_view RemoveTrailingSlash(std::string_view path) {
|
|
||||||
if (path.empty()) {
|
|
||||||
return path;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (path.back() == '\\' || path.back() == '/') {
|
|
||||||
path.remove_suffix(1);
|
|
||||||
return path;
|
|
||||||
}
|
|
||||||
|
|
||||||
return path;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string SanitizePath(std::string_view path_, DirectorySeparator directory_separator) {
|
|
||||||
std::string path(path_);
|
|
||||||
char type1 = directory_separator == DirectorySeparator::BackwardSlash ? '/' : '\\';
|
|
||||||
char type2 = directory_separator == DirectorySeparator::BackwardSlash ? '\\' : '/';
|
|
||||||
|
|
||||||
if (directory_separator == DirectorySeparator::PlatformDefault) {
|
|
||||||
#ifdef _WIN32
|
|
||||||
type1 = '/';
|
|
||||||
type2 = '\\';
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
std::replace(path.begin(), path.end(), type1, type2);
|
|
||||||
|
|
||||||
auto start = path.begin();
|
|
||||||
#ifdef _WIN32
|
|
||||||
// allow network paths which start with a double backslash (e.g. \\server\share)
|
|
||||||
if (start != path.end())
|
|
||||||
++start;
|
|
||||||
#endif
|
|
||||||
path.erase(std::unique(start, path.end(),
|
|
||||||
[type2](char c1, char c2) { return c1 == type2 && c2 == type2; }),
|
|
||||||
path.end());
|
|
||||||
return std::string(RemoveTrailingSlash(path));
|
|
||||||
}
|
|
||||||
|
|
||||||
IOFile::IOFile() = default;
|
|
||||||
|
|
||||||
IOFile::IOFile(const std::string& filename, const char openmode[], int flags)
|
|
||||||
: filename(filename), openmode(openmode), flags(flags) {
|
|
||||||
Open();
|
|
||||||
}
|
|
||||||
|
|
||||||
IOFile::~IOFile() {
|
|
||||||
Close();
|
|
||||||
}
|
|
||||||
|
|
||||||
IOFile::IOFile(IOFile&& other) noexcept {
|
|
||||||
Swap(other);
|
|
||||||
}
|
|
||||||
|
|
||||||
IOFile& IOFile::operator=(IOFile&& other) noexcept {
|
|
||||||
Swap(other);
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
void IOFile::Swap(IOFile& other) noexcept {
|
|
||||||
std::swap(m_file, other.m_file);
|
|
||||||
std::swap(m_good, other.m_good);
|
|
||||||
std::swap(filename, other.filename);
|
|
||||||
std::swap(openmode, other.openmode);
|
|
||||||
std::swap(flags, other.flags);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool IOFile::Open() {
|
|
||||||
Close();
|
|
||||||
|
|
||||||
#ifdef _WIN32
|
|
||||||
if (flags != 0) {
|
|
||||||
m_file = _wfsopen(Common::UTF8ToUTF16W(filename).c_str(),
|
|
||||||
Common::UTF8ToUTF16W(openmode).c_str(), flags);
|
|
||||||
m_good = m_file != nullptr;
|
|
||||||
} else {
|
|
||||||
m_good = _wfopen_s(&m_file, Common::UTF8ToUTF16W(filename).c_str(),
|
|
||||||
Common::UTF8ToUTF16W(openmode).c_str()) == 0;
|
|
||||||
}
|
|
||||||
#else
|
|
||||||
m_file = std::fopen(filename.c_str(), openmode.c_str());
|
|
||||||
m_good = m_file != nullptr;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
return m_good;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool IOFile::Close() {
|
|
||||||
if (!IsOpen() || 0 != std::fclose(m_file))
|
|
||||||
m_good = false;
|
|
||||||
|
|
||||||
m_file = nullptr;
|
|
||||||
return m_good;
|
|
||||||
}
|
|
||||||
|
|
||||||
u64 IOFile::GetSize() const {
|
|
||||||
if (IsOpen())
|
|
||||||
return Common::FS::GetSize(m_file);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool IOFile::Seek(s64 off, int origin) {
|
|
||||||
if (!IsOpen() || 0 != fseeko(m_file, off, origin))
|
|
||||||
m_good = false;
|
|
||||||
|
|
||||||
return m_good;
|
|
||||||
}
|
|
||||||
|
|
||||||
u64 IOFile::Tell() const {
|
|
||||||
if (IsOpen())
|
|
||||||
return ftello(m_file);
|
|
||||||
|
|
||||||
return std::numeric_limits<u64>::max();
|
|
||||||
}
|
|
||||||
|
|
||||||
bool IOFile::Flush() {
|
|
||||||
if (!IsOpen() || 0 != std::fflush(m_file))
|
|
||||||
m_good = false;
|
|
||||||
|
|
||||||
return m_good;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::size_t IOFile::ReadImpl(void* data, std::size_t length, std::size_t data_size) {
|
|
||||||
if (!IsOpen()) {
|
|
||||||
m_good = false;
|
|
||||||
return std::numeric_limits<std::size_t>::max();
|
|
||||||
}
|
|
||||||
|
|
||||||
if (length == 0) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
DEBUG_ASSERT(data != nullptr);
|
|
||||||
|
|
||||||
return std::fread(data, data_size, length, m_file);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::size_t IOFile::WriteImpl(const void* data, std::size_t length, std::size_t data_size) {
|
|
||||||
if (!IsOpen()) {
|
|
||||||
m_good = false;
|
|
||||||
return std::numeric_limits<std::size_t>::max();
|
|
||||||
}
|
|
||||||
|
|
||||||
if (length == 0) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
DEBUG_ASSERT(data != nullptr);
|
|
||||||
|
|
||||||
return std::fwrite(data, data_size, length, m_file);
|
|
||||||
}
|
|
||||||
|
|
||||||
bool IOFile::Resize(u64 size) {
|
|
||||||
if (!IsOpen() || 0 !=
|
|
||||||
#ifdef _WIN32
|
|
||||||
// ector: _chsize sucks, not 64-bit safe
|
|
||||||
// F|RES: changed to _chsize_s. i think it is 64-bit safe
|
|
||||||
_chsize_s(_fileno(m_file), size)
|
|
||||||
#else
|
|
||||||
// TODO: handle 64bit and growing
|
|
||||||
ftruncate(fileno(m_file), size)
|
|
||||||
#endif
|
|
||||||
)
|
|
||||||
m_good = false;
|
|
||||||
|
|
||||||
return m_good;
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace Common::FS
|
|
||||||
@ -1,392 +0,0 @@
|
|||||||
// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
|
|
||||||
// Licensed under GPLv2 or any later version
|
|
||||||
// Refer to the license.txt file included.
|
|
||||||
|
|
||||||
#pragma once
|
|
||||||
|
|
||||||
#include <array>
|
|
||||||
#include <cstdio>
|
|
||||||
#include <filesystem>
|
|
||||||
#include <fstream>
|
|
||||||
#include <functional>
|
|
||||||
#include <limits>
|
|
||||||
#include <optional>
|
|
||||||
#include <string>
|
|
||||||
#include <string_view>
|
|
||||||
#include <type_traits>
|
|
||||||
#include <vector>
|
|
||||||
#include <boost/serialization/split_member.hpp>
|
|
||||||
#include <boost/serialization/string.hpp>
|
|
||||||
#include <boost/serialization/wrapper.hpp>
|
|
||||||
#include "common/common_types.h"
|
|
||||||
#ifdef _MSC_VER
|
|
||||||
#include "common/string_util.h"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
namespace Common::FS {
|
|
||||||
|
|
||||||
// User paths for GetUserPath
|
|
||||||
enum class UserPath {
|
|
||||||
CacheDir,
|
|
||||||
CheatsDir,
|
|
||||||
ConfigDir,
|
|
||||||
DLLDir,
|
|
||||||
DumpDir,
|
|
||||||
LoadDir,
|
|
||||||
LogDir,
|
|
||||||
NANDDir,
|
|
||||||
RootDir,
|
|
||||||
SDMCDir,
|
|
||||||
ShaderDir,
|
|
||||||
StatesDir,
|
|
||||||
SysDataDir,
|
|
||||||
UserDir,
|
|
||||||
};
|
|
||||||
|
|
||||||
// Replaces install-specific paths with standard placeholders, and back again
|
|
||||||
std::string SerializePath(const std::string& input, bool is_saving);
|
|
||||||
|
|
||||||
// A serializable path string
|
|
||||||
struct Path : public boost::serialization::wrapper_traits<const Path> {
|
|
||||||
std::string& str;
|
|
||||||
|
|
||||||
explicit Path(std::string& _str) : str(_str) {}
|
|
||||||
|
|
||||||
static const Path make(std::string& str) {
|
|
||||||
return Path(str);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class Archive>
|
|
||||||
void save(Archive& ar, const unsigned int) const {
|
|
||||||
auto s_path = SerializePath(str, true);
|
|
||||||
ar << s_path;
|
|
||||||
}
|
|
||||||
template <class Archive>
|
|
||||||
void load(Archive& ar, const unsigned int) const {
|
|
||||||
ar >> str;
|
|
||||||
str = SerializePath(str, false);
|
|
||||||
}
|
|
||||||
|
|
||||||
BOOST_SERIALIZATION_SPLIT_MEMBER();
|
|
||||||
friend class boost::serialization::access;
|
|
||||||
};
|
|
||||||
|
|
||||||
// FileSystem tree node/
|
|
||||||
struct FSTEntry {
|
|
||||||
bool isDirectory;
|
|
||||||
u64 size; // file length or number of entries from children
|
|
||||||
std::string physicalName; // name on disk
|
|
||||||
std::string virtualName; // name in FST names table
|
|
||||||
std::vector<FSTEntry> children;
|
|
||||||
|
|
||||||
private:
|
|
||||||
template <class Archive>
|
|
||||||
void serialize(Archive& ar, const unsigned int) {
|
|
||||||
ar& isDirectory;
|
|
||||||
ar& size;
|
|
||||||
ar& Path::make(physicalName);
|
|
||||||
ar& Path::make(virtualName);
|
|
||||||
ar& children;
|
|
||||||
}
|
|
||||||
friend class boost::serialization::access;
|
|
||||||
};
|
|
||||||
|
|
||||||
// Returns true if the path exists
|
|
||||||
[[nodiscard]] bool Exists(const std::filesystem::path& path);
|
|
||||||
|
|
||||||
// Returns true if path is a directory
|
|
||||||
[[nodiscard]] bool IsDirectory(const std::filesystem::path& path);
|
|
||||||
|
|
||||||
// Returns the size of filename (64bit)
|
|
||||||
[[nodiscard]] u64 GetSize(const std::filesystem::path& path);
|
|
||||||
|
|
||||||
// Overloaded GetSize, accepts FILE*
|
|
||||||
[[nodiscard]] u64 GetSize(FILE* f);
|
|
||||||
|
|
||||||
// Returns true if successful, or path already exists.
|
|
||||||
bool CreateDir(const std::filesystem::path& path);
|
|
||||||
|
|
||||||
// Creates the full path of path. Returns true on success
|
|
||||||
bool CreateFullPath(const std::filesystem::path& path);
|
|
||||||
|
|
||||||
// Deletes a given file at the path.
|
|
||||||
// This will also delete empty directories.
|
|
||||||
// Return true on success
|
|
||||||
bool Delete(const std::filesystem::path& path);
|
|
||||||
|
|
||||||
// Renames file src to dst, returns true on success
|
|
||||||
bool Rename(const std::filesystem::path& src, const std::filesystem::path& dst);
|
|
||||||
|
|
||||||
// copies file src to dst, returns true on success
|
|
||||||
bool Copy(const std::filesystem::path& src, const std::filesystem::path& dst);
|
|
||||||
|
|
||||||
// creates an empty file filename, returns true on success
|
|
||||||
bool CreateEmptyFile(const std::string& filename);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param num_entries_out to be assigned by the callable with the number of iterated directory
|
|
||||||
* entries, never null
|
|
||||||
* @param directory the path to the enclosing directory
|
|
||||||
* @param virtual_name the entry name, without any preceding directory info
|
|
||||||
* @return whether handling the entry succeeded
|
|
||||||
*/
|
|
||||||
using DirectoryEntryCallable = std::function<bool(
|
|
||||||
u64* num_entries_out, const std::string& directory, const std::string& virtual_name)>;
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Scans a directory, calling the callback for each file/directory contained within.
|
|
||||||
* If the callback returns failure, scanning halts and this function returns failure as well
|
|
||||||
* @param num_entries_out assigned by the function with the number of iterated directory entries,
|
|
||||||
* can be null
|
|
||||||
* @param directory the directory to scan
|
|
||||||
* @param callback The callback which will be called for each entry
|
|
||||||
* @return whether scanning the directory succeeded
|
|
||||||
*/
|
|
||||||
bool ForeachDirectoryEntry(u64* num_entries_out, const std::string& directory,
|
|
||||||
DirectoryEntryCallable callback);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Scans the directory tree, storing the results.
|
|
||||||
* @param directory the parent directory to start scanning from
|
|
||||||
* @param parent_entry FSTEntry where the filesystem tree results will be stored.
|
|
||||||
* @param recursion Number of children directories to read before giving up.
|
|
||||||
* @return the total number of files/directories found
|
|
||||||
*/
|
|
||||||
u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
|
|
||||||
unsigned int recursion = 0);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Recursively searches through a FSTEntry for files, and stores them.
|
|
||||||
* @param directory The FSTEntry to start scanning from
|
|
||||||
* @param parent_entry FSTEntry vector where the results will be stored.
|
|
||||||
*/
|
|
||||||
void GetAllFilesFromNestedEntries(FSTEntry& directory, std::vector<FSTEntry>& output);
|
|
||||||
|
|
||||||
// Deletes the given path and anything under it. Returns true on success.
|
|
||||||
bool DeleteDirRecursively(const std::filesystem::path& path);
|
|
||||||
|
|
||||||
// Returns the current directory
|
|
||||||
[[nodiscard]] std::optional<std::filesystem::path> GetCurrentDir();
|
|
||||||
|
|
||||||
// Create directory and copy contents (does not overwrite existing files)
|
|
||||||
void CopyDir(const std::filesystem::path& src, const std::filesystem::path& dst);
|
|
||||||
|
|
||||||
// Set the current directory to given path
|
|
||||||
bool SetCurrentDir(const std::filesystem::path& path);
|
|
||||||
|
|
||||||
void SetUserPath(const std::string& path = "");
|
|
||||||
|
|
||||||
void SetCurrentRomPath(const std::string& path);
|
|
||||||
|
|
||||||
// Returns a pointer to a string with a Citra data dir in the user's home
|
|
||||||
// directory. To be used in "multi-user" mode (that is, installed).
|
|
||||||
[[nodiscard]] const std::string& GetUserPath(UserPath path);
|
|
||||||
|
|
||||||
// Returns a pointer to a string with the default Citra data dir in the user's home
|
|
||||||
// directory.
|
|
||||||
[[nodiscard]] const std::string& GetDefaultUserPath(UserPath path);
|
|
||||||
|
|
||||||
// Update the Global Path with the new value
|
|
||||||
const void UpdateUserPath(UserPath path, const std::string& filename);
|
|
||||||
|
|
||||||
// Returns the path to where the sys file are
|
|
||||||
[[nodiscard]] std::string GetSysDirectory();
|
|
||||||
|
|
||||||
#ifdef __APPLE__
|
|
||||||
[[nodiscard]] std::string GetBundleDirectory();
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#ifdef _WIN32
|
|
||||||
[[nodiscard]] const std::string& GetExeDirectory();
|
|
||||||
[[nodiscard]] std::string AppDataRoamingDirectory();
|
|
||||||
#endif
|
|
||||||
|
|
||||||
std::size_t WriteStringToFile(bool text_file, const std::string& filename, std::string_view str);
|
|
||||||
|
|
||||||
std::size_t ReadFileToString(bool text_file, const std::string& filename, std::string& str);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Splits the filename into 8.3 format
|
|
||||||
* Loosely implemented following https://en.wikipedia.org/wiki/8.3_filename
|
|
||||||
* @param filename The normal filename to use
|
|
||||||
* @param short_name A 9-char array in which the short name will be written
|
|
||||||
* @param extension A 4-char array in which the extension will be written
|
|
||||||
*/
|
|
||||||
void SplitFilename83(const std::string& filename, std::array<char, 9>& short_name,
|
|
||||||
std::array<char, 4>& extension);
|
|
||||||
|
|
||||||
// Splits the path on '/' or '\' and put the components into a vector
|
|
||||||
// i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
|
|
||||||
[[nodiscard]] std::vector<std::string> SplitPathComponents(std::string_view filename);
|
|
||||||
|
|
||||||
// Gets all of the text up to the last '/' or '\' in the path.
|
|
||||||
[[nodiscard]] std::string_view GetParentPath(std::string_view path);
|
|
||||||
|
|
||||||
// Gets all of the text after the first '/' or '\' in the path.
|
|
||||||
[[nodiscard]] std::string_view GetPathWithoutTop(std::string_view path);
|
|
||||||
|
|
||||||
// Gets the filename of the path
|
|
||||||
[[nodiscard]] std::string_view GetFilename(std::string_view path);
|
|
||||||
|
|
||||||
// Gets the extension of the filename
|
|
||||||
[[nodiscard]] std::string_view GetExtensionFromFilename(std::string_view name);
|
|
||||||
|
|
||||||
// Removes the final '/' or '\' if one exists
|
|
||||||
[[nodiscard]] std::string_view RemoveTrailingSlash(std::string_view path);
|
|
||||||
|
|
||||||
// Creates a new vector containing indices [first, last) from the original.
|
|
||||||
template <typename T>
|
|
||||||
[[nodiscard]] std::vector<T> SliceVector(const std::vector<T>& vector, std::size_t first,
|
|
||||||
std::size_t last) {
|
|
||||||
if (first >= last) {
|
|
||||||
return {};
|
|
||||||
}
|
|
||||||
last = std::min<std::size_t>(last, vector.size());
|
|
||||||
return std::vector<T>(vector.begin() + first, vector.begin() + first + last);
|
|
||||||
}
|
|
||||||
|
|
||||||
enum class DirectorySeparator {
|
|
||||||
ForwardSlash,
|
|
||||||
BackwardSlash,
|
|
||||||
PlatformDefault,
|
|
||||||
};
|
|
||||||
|
|
||||||
// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
|
|
||||||
// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
|
|
||||||
[[nodiscard]] std::string SanitizePath(
|
|
||||||
std::string_view path,
|
|
||||||
DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);
|
|
||||||
|
|
||||||
// simple wrapper for cstdlib file functions to
|
|
||||||
// hopefully will make error checking easier
|
|
||||||
// and make forgetting an fclose() harder
|
|
||||||
class IOFile : public NonCopyable {
|
|
||||||
public:
|
|
||||||
IOFile();
|
|
||||||
|
|
||||||
// flags is used for windows specific file open mode flags, which
|
|
||||||
// allows citra to open the logs in shared write mode, so that the file
|
|
||||||
// isn't considered "locked" while citra is open and people can open the log file and view it
|
|
||||||
IOFile(const std::string& filename, const char openmode[], int flags = 0);
|
|
||||||
|
|
||||||
~IOFile();
|
|
||||||
|
|
||||||
IOFile(IOFile&& other) noexcept;
|
|
||||||
IOFile& operator=(IOFile&& other) noexcept;
|
|
||||||
|
|
||||||
void Swap(IOFile& other) noexcept;
|
|
||||||
|
|
||||||
bool Close();
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
std::size_t ReadArray(T* data, std::size_t length) {
|
|
||||||
static_assert(std::is_trivially_copyable_v<T>,
|
|
||||||
"Given array does not consist of trivially copyable objects");
|
|
||||||
|
|
||||||
std::size_t items_read = ReadImpl(data, length, sizeof(T));
|
|
||||||
if (items_read != length)
|
|
||||||
m_good = false;
|
|
||||||
|
|
||||||
return items_read;
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
std::size_t WriteArray(const T* data, std::size_t length) {
|
|
||||||
static_assert(std::is_trivially_copyable_v<T>,
|
|
||||||
"Given array does not consist of trivially copyable objects");
|
|
||||||
|
|
||||||
std::size_t items_written = WriteImpl(data, length, sizeof(T));
|
|
||||||
if (items_written != length)
|
|
||||||
m_good = false;
|
|
||||||
|
|
||||||
return items_written;
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
std::size_t ReadBytes(T* data, std::size_t length) {
|
|
||||||
static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
|
|
||||||
return ReadArray(reinterpret_cast<char*>(data), length);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
std::size_t WriteBytes(const T* data, std::size_t length) {
|
|
||||||
static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
|
|
||||||
return WriteArray(reinterpret_cast<const char*>(data), length);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
std::size_t WriteObject(const T& object) {
|
|
||||||
static_assert(!std::is_pointer_v<T>, "WriteObject arguments must not be a pointer");
|
|
||||||
return WriteArray(&object, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::size_t WriteString(std::string_view str) {
|
|
||||||
return WriteArray(str.data(), str.length());
|
|
||||||
}
|
|
||||||
|
|
||||||
[[nodiscard]] bool IsOpen() const {
|
|
||||||
return nullptr != m_file;
|
|
||||||
}
|
|
||||||
|
|
||||||
// m_good is set to false when a read, write or other function fails
|
|
||||||
[[nodiscard]] bool IsGood() const {
|
|
||||||
return m_good;
|
|
||||||
}
|
|
||||||
[[nodiscard]] explicit operator bool() const {
|
|
||||||
return IsGood();
|
|
||||||
}
|
|
||||||
|
|
||||||
bool Seek(s64 off, int origin);
|
|
||||||
[[nodiscard]] u64 Tell() const;
|
|
||||||
[[nodiscard]] u64 GetSize() const;
|
|
||||||
bool Resize(u64 size);
|
|
||||||
bool Flush();
|
|
||||||
|
|
||||||
// clear error state
|
|
||||||
void Clear() {
|
|
||||||
m_good = true;
|
|
||||||
std::clearerr(m_file);
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
std::size_t ReadImpl(void* data, std::size_t length, std::size_t data_size);
|
|
||||||
std::size_t WriteImpl(const void* data, std::size_t length, std::size_t data_size);
|
|
||||||
|
|
||||||
bool Open();
|
|
||||||
|
|
||||||
std::FILE* m_file = nullptr;
|
|
||||||
bool m_good = true;
|
|
||||||
|
|
||||||
std::string filename;
|
|
||||||
std::string openmode;
|
|
||||||
u32 flags;
|
|
||||||
|
|
||||||
template <class Archive>
|
|
||||||
void serialize(Archive& ar, const unsigned int) {
|
|
||||||
ar& Path::make(filename);
|
|
||||||
ar& openmode;
|
|
||||||
ar& flags;
|
|
||||||
u64 pos;
|
|
||||||
if (Archive::is_saving::value) {
|
|
||||||
pos = Tell();
|
|
||||||
}
|
|
||||||
ar& pos;
|
|
||||||
if (Archive::is_loading::value) {
|
|
||||||
Open();
|
|
||||||
Seek(pos, SEEK_SET);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
friend class boost::serialization::access;
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace Common::FS
|
|
||||||
|
|
||||||
// To deal with Windows being dumb at unicode:
|
|
||||||
template <typename T>
|
|
||||||
void OpenFStream(T& fstream, const std::string& filename, std::ios_base::openmode openmode) {
|
|
||||||
#ifdef _MSC_VER
|
|
||||||
fstream.open(Common::UTF8ToUTF16W(filename), openmode);
|
|
||||||
#else
|
|
||||||
fstream.open(filename, openmode);
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
415
src/common/fs/file.cpp
Normal file
415
src/common/fs/file.cpp
Normal file
@ -0,0 +1,415 @@
|
|||||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#include "common/fs/file.h"
|
||||||
|
#include "common/fs/fs.h"
|
||||||
|
#include "common/logging/log.h"
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
#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 Common::FS {
|
||||||
|
|
||||||
|
namespace fs = std::filesystem;
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Converts the file access mode and file type enums to a file access mode wide string.
|
||||||
|
*
|
||||||
|
* @param mode File access mode
|
||||||
|
* @param type File type
|
||||||
|
*
|
||||||
|
* @returns A pointer to a wide string representing the file access mode.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] constexpr const wchar_t* AccessModeToWStr(FileAccessMode mode, FileType type) {
|
||||||
|
switch (type) {
|
||||||
|
case FileType::BinaryFile:
|
||||||
|
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 FileType::TextFile:
|
||||||
|
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"";
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Converts the file-share access flag enum to a Windows defined file-share access flag.
|
||||||
|
*
|
||||||
|
* @param flag File-share access flag
|
||||||
|
*
|
||||||
|
* @returns Windows defined file-share access flag.
|
||||||
|
*/
|
||||||
|
[[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
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Converts the file access mode and file type enums to a file access mode string.
|
||||||
|
*
|
||||||
|
* @param mode File access mode
|
||||||
|
* @param type File type
|
||||||
|
*
|
||||||
|
* @returns A pointer to a string representing the file access mode.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] constexpr const char* AccessModeToStr(FileAccessMode mode, FileType type) {
|
||||||
|
switch (type) {
|
||||||
|
case FileType::BinaryFile:
|
||||||
|
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 FileType::TextFile:
|
||||||
|
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
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Converts the seek origin enum to a seek origin integer.
|
||||||
|
*
|
||||||
|
* @param origin Seek origin
|
||||||
|
*
|
||||||
|
* @returns Seek origin integer.
|
||||||
|
*/
|
||||||
|
[[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;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
} // Anonymous namespace
|
||||||
|
|
||||||
|
std::string ReadStringFromFile(const std::filesystem::path& path, FileType type) {
|
||||||
|
if (!IsFile(path)) {
|
||||||
|
return "";
|
||||||
|
}
|
||||||
|
|
||||||
|
IOFile io_file{path, FileAccessMode::Read, type};
|
||||||
|
|
||||||
|
return io_file.ReadString(io_file.GetSize());
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
|
||||||
|
std::string_view string) {
|
||||||
|
if (Exists(path) && !IsFile(path)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
IOFile io_file{path, FileAccessMode::Write, type};
|
||||||
|
|
||||||
|
return io_file.WriteString(string);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
|
||||||
|
std::string_view string) {
|
||||||
|
if (Exists(path) && !IsFile(path)) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
IOFile io_file{path, FileAccessMode::Append, type};
|
||||||
|
|
||||||
|
return io_file.WriteString(string);
|
||||||
|
}
|
||||||
|
|
||||||
|
IOFile::IOFile() = default;
|
||||||
|
|
||||||
|
IOFile::IOFile(const std::string& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
|
||||||
|
Open(path, mode, type, flag);
|
||||||
|
}
|
||||||
|
|
||||||
|
IOFile::IOFile(std::string_view path, FileAccessMode mode, FileType type, FileShareFlag flag) {
|
||||||
|
Open(path, mode, type, flag);
|
||||||
|
}
|
||||||
|
|
||||||
|
IOFile::IOFile(const fs::path& path, FileAccessMode mode, FileType type, FileShareFlag flag) {
|
||||||
|
Open(path, mode, type, flag);
|
||||||
|
}
|
||||||
|
|
||||||
|
IOFile::~IOFile() {
|
||||||
|
Close();
|
||||||
|
}
|
||||||
|
|
||||||
|
IOFile::IOFile(IOFile&& other) noexcept {
|
||||||
|
std::swap(file_path, other.file_path);
|
||||||
|
std::swap(file_access_mode, other.file_access_mode);
|
||||||
|
std::swap(file_type, other.file_type);
|
||||||
|
std::swap(file, other.file);
|
||||||
|
}
|
||||||
|
|
||||||
|
IOFile& IOFile::operator=(IOFile&& other) noexcept {
|
||||||
|
std::swap(file_path, other.file_path);
|
||||||
|
std::swap(file_access_mode, other.file_access_mode);
|
||||||
|
std::swap(file_type, other.file_type);
|
||||||
|
std::swap(file, other.file);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
fs::path IOFile::GetPath() const {
|
||||||
|
return file_path;
|
||||||
|
}
|
||||||
|
|
||||||
|
FileAccessMode IOFile::GetAccessMode() const {
|
||||||
|
return file_access_mode;
|
||||||
|
}
|
||||||
|
|
||||||
|
FileType IOFile::GetType() const {
|
||||||
|
return file_type;
|
||||||
|
}
|
||||||
|
|
||||||
|
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));
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
file = std::fopen(path.c_str(), AccessModeToStr(mode, type));
|
||||||
|
#endif
|
||||||
|
|
||||||
|
if (!IsOpen()) {
|
||||||
|
const auto ec = std::error_code{errno, std::generic_category()};
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to open the file at path={}, ec_message={}",
|
||||||
|
PathToUTF8String(file_path), ec.message());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void IOFile::Close() {
|
||||||
|
if (!IsOpen()) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
errno = 0;
|
||||||
|
|
||||||
|
const auto close_result = std::fclose(file) == 0;
|
||||||
|
|
||||||
|
if (!close_result) {
|
||||||
|
const auto ec = std::error_code{errno, std::generic_category()};
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to close the file at path={}, ec_message={}",
|
||||||
|
PathToUTF8String(file_path), ec.message());
|
||||||
|
}
|
||||||
|
|
||||||
|
file = nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IOFile::IsOpen() const {
|
||||||
|
return file != nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string IOFile::ReadString(size_t length) const {
|
||||||
|
std::vector<char> string_buffer(length);
|
||||||
|
|
||||||
|
const auto chars_read = ReadSpan<char>(string_buffer);
|
||||||
|
const auto string_size = chars_read != length ? chars_read : length;
|
||||||
|
|
||||||
|
return std::string{string_buffer.data(), string_size};
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t IOFile::WriteString(std::span<const char> string) const {
|
||||||
|
return WriteSpan(string);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IOFile::Flush() const {
|
||||||
|
if (!IsOpen()) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
errno = 0;
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
const auto flush_result = std::fflush(file) == 0;
|
||||||
|
#else
|
||||||
|
const auto flush_result = std::fflush(file) == 0;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
if (!flush_result) {
|
||||||
|
const auto ec = std::error_code{errno, std::generic_category()};
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to flush the file at path={}, ec_message={}",
|
||||||
|
PathToUTF8String(file_path), ec.message());
|
||||||
|
}
|
||||||
|
|
||||||
|
return flush_result;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IOFile::Commit() const {
|
||||||
|
if (!IsOpen()) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
errno = 0;
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
const auto commit_result = std::fflush(file) == 0 && _commit(fileno(file)) == 0;
|
||||||
|
#else
|
||||||
|
const auto commit_result = std::fflush(file) == 0 && fsync(fileno(file)) == 0;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
if (!commit_result) {
|
||||||
|
const auto ec = std::error_code{errno, std::generic_category()};
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to commit the file at path={}, ec_message={}",
|
||||||
|
PathToUTF8String(file_path), ec.message());
|
||||||
|
}
|
||||||
|
|
||||||
|
return commit_result;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IOFile::SetSize(u64 size) const {
|
||||||
|
if (!IsOpen()) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
errno = 0;
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
const auto set_size_result = _chsize_s(fileno(file), static_cast<s64>(size)) == 0;
|
||||||
|
#else
|
||||||
|
const auto set_size_result = ftruncate(fileno(file), static_cast<s64>(size)) == 0;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
if (!set_size_result) {
|
||||||
|
const auto ec = std::error_code{errno, std::generic_category()};
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to resize the file at path={}, size={}, ec_message={}",
|
||||||
|
PathToUTF8String(file_path), size, ec.message());
|
||||||
|
}
|
||||||
|
|
||||||
|
return set_size_result;
|
||||||
|
}
|
||||||
|
|
||||||
|
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);
|
||||||
|
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
const auto file_size = fs::file_size(file_path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to retrieve the file size of path={}, ec_message={}",
|
||||||
|
PathToUTF8String(file_path), ec.message());
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return file_size;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IOFile::Seek(s64 offset, SeekOrigin origin) const {
|
||||||
|
if (!IsOpen()) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
errno = 0;
|
||||||
|
|
||||||
|
const auto seek_result = fseeko(file, offset, ToSeekOrigin(origin)) == 0;
|
||||||
|
|
||||||
|
if (!seek_result) {
|
||||||
|
const auto ec = std::error_code{errno, std::generic_category()};
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to seek the file at path={}, offset={}, origin={}, ec_message={}",
|
||||||
|
PathToUTF8String(file_path), offset, origin, ec.message());
|
||||||
|
}
|
||||||
|
|
||||||
|
return seek_result;
|
||||||
|
}
|
||||||
|
|
||||||
|
s64 IOFile::Tell() const {
|
||||||
|
if (!IsOpen()) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
errno = 0;
|
||||||
|
|
||||||
|
return ftello(file);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace Common::FS
|
||||||
459
src/common/fs/file.h
Normal file
459
src/common/fs/file.h
Normal file
@ -0,0 +1,459 @@
|
|||||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <cstdio>
|
||||||
|
#include <filesystem>
|
||||||
|
#include <span>
|
||||||
|
#include <type_traits>
|
||||||
|
|
||||||
|
#include "common/concepts.h"
|
||||||
|
#include "common/fs/fs_types.h"
|
||||||
|
#include "common/fs/fs_util.h"
|
||||||
|
|
||||||
|
namespace Common::FS {
|
||||||
|
|
||||||
|
enum class SeekOrigin {
|
||||||
|
SetOrigin, // Seeks from the start of the file.
|
||||||
|
CurrentPosition, // Seeks from the current file pointer position.
|
||||||
|
End, // Seeks from the end of the file.
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Opens a file stream at path with the specified open mode.
|
||||||
|
*
|
||||||
|
* @param file_stream Reference to file stream
|
||||||
|
* @param path Filesystem path
|
||||||
|
* @param open_mode File stream open mode
|
||||||
|
*/
|
||||||
|
template <typename FileStream>
|
||||||
|
void OpenFileStream(FileStream& file_stream, const std::filesystem::path& path,
|
||||||
|
std::ios_base::openmode open_mode) {
|
||||||
|
file_stream.open(path, open_mode);
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename FileStream, typename Path>
|
||||||
|
void OpenFileStream(FileStream& file_stream, const Path& path, std::ios_base::openmode open_mode) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
file_stream.open(ToU8String(path), open_mode);
|
||||||
|
} else {
|
||||||
|
file_stream.open(std::filesystem::path{path}, open_mode);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
* @param type File type
|
||||||
|
*
|
||||||
|
* @returns A string of the contents read from the file.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::string ReadStringFromFile(const std::filesystem::path& path, FileType type);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] std::string ReadStringFromFile(const Path& path, FileType type) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return ReadStringFromFile(ToU8String(path), type);
|
||||||
|
} else {
|
||||||
|
return ReadStringFromFile(std::filesystem::path{path}, type);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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 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.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
* @param type File type
|
||||||
|
*
|
||||||
|
* @returns Number of characters successfully written.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] size_t WriteStringToFile(const std::filesystem::path& path, FileType type,
|
||||||
|
std::string_view string);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] size_t WriteStringToFile(const Path& path, FileType type, std::string_view string) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return WriteStringToFile(ToU8String(path), type, string);
|
||||||
|
} else {
|
||||||
|
return WriteStringToFile(std::filesystem::path{path}, type, string);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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 the filesystem object at path exists and is not a regular file, this function returns 0.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
* @param type File type
|
||||||
|
*
|
||||||
|
* @returns Number of characters successfully written.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] size_t AppendStringToFile(const std::filesystem::path& path, FileType type,
|
||||||
|
std::string_view string);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] size_t AppendStringToFile(const Path& path, FileType type, std::string_view string) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return AppendStringToFile(ToU8String(path), type, string);
|
||||||
|
} else {
|
||||||
|
return AppendStringToFile(std::filesystem::path{path}, type, string);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
class IOFile final {
|
||||||
|
public:
|
||||||
|
IOFile();
|
||||||
|
|
||||||
|
explicit IOFile(const std::string& path, FileAccessMode mode,
|
||||||
|
FileType type = FileType::BinaryFile,
|
||||||
|
FileShareFlag flag = FileShareFlag::ShareReadOnly);
|
||||||
|
|
||||||
|
explicit IOFile(std::string_view path, FileAccessMode mode,
|
||||||
|
FileType type = FileType::BinaryFile,
|
||||||
|
FileShareFlag flag = FileShareFlag::ShareReadOnly);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* An IOFile is a lightweight wrapper on C Library file operations.
|
||||||
|
* Automatically closes an open file on the destruction of an IOFile object.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
* @param mode File access mode
|
||||||
|
* @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
|
||||||
|
*/
|
||||||
|
explicit IOFile(const std::filesystem::path& path, FileAccessMode mode,
|
||||||
|
FileType type = FileType::BinaryFile,
|
||||||
|
FileShareFlag flag = FileShareFlag::ShareReadOnly);
|
||||||
|
|
||||||
|
~IOFile();
|
||||||
|
|
||||||
|
IOFile(const IOFile&) = delete;
|
||||||
|
IOFile& operator=(const IOFile&) = delete;
|
||||||
|
|
||||||
|
IOFile(IOFile&& other) noexcept;
|
||||||
|
IOFile& operator=(IOFile&& other) noexcept;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the path of the file.
|
||||||
|
*
|
||||||
|
* @returns The path of the file.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::filesystem::path GetPath() const;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the access mode of the file.
|
||||||
|
*
|
||||||
|
* @returns The access mode of the file.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] FileAccessMode GetAccessMode() const;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the type of the file.
|
||||||
|
*
|
||||||
|
* @returns The type of the file.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] FileType GetType() const;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Opens a file at path with the specified file access mode.
|
||||||
|
* This function behaves differently depending on the FileAccessMode.
|
||||||
|
* These behaviors are documented in each enum value of FileAccessMode.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
* @param mode File access mode
|
||||||
|
* @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
|
||||||
|
*/
|
||||||
|
void Open(const std::filesystem::path& path, FileAccessMode mode,
|
||||||
|
FileType type = FileType::BinaryFile,
|
||||||
|
FileShareFlag flag = FileShareFlag::ShareReadOnly);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
void Open(const Path& path, FileAccessMode mode, FileType type = FileType::BinaryFile,
|
||||||
|
FileShareFlag flag = FileShareFlag::ShareReadOnly) {
|
||||||
|
using ValueType = typename Path::value_type;
|
||||||
|
if constexpr (IsChar<ValueType>) {
|
||||||
|
Open(ToU8String(path), mode, type, flag);
|
||||||
|
} else {
|
||||||
|
Open(std::filesystem::path{path}, mode, type, flag);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Closes the file if it is opened.
|
||||||
|
void Close();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Checks whether the file is open.
|
||||||
|
* Use this to check whether the calls to Open() or Close() succeeded.
|
||||||
|
*
|
||||||
|
* @returns True if the file is open, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool IsOpen() const;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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
|
||||||
|
* calls ReadObject and T must be a trivially copyable object.
|
||||||
|
*
|
||||||
|
* See ReadSpan for more details if T is a contiguous container.
|
||||||
|
* See ReadObject for more details if T is a trivially copyable object.
|
||||||
|
*
|
||||||
|
* @tparam T Contiguous container or trivially copyable object
|
||||||
|
*
|
||||||
|
* @param data Container of T::value_type data or reference to object
|
||||||
|
*
|
||||||
|
* @returns Count of T::value_type data or objects successfully read.
|
||||||
|
*/
|
||||||
|
template <typename T>
|
||||||
|
[[nodiscard]] size_t Read(T& data) const {
|
||||||
|
if constexpr (IsContiguousContainer<T>) {
|
||||||
|
using ContiguousType = typename T::value_type;
|
||||||
|
static_assert(std::is_trivially_copyable_v<ContiguousType>,
|
||||||
|
"Data type must be trivially copyable.");
|
||||||
|
return ReadSpan<ContiguousType>(data);
|
||||||
|
} else {
|
||||||
|
return ReadObject(data) ? 1 : 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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
|
||||||
|
* calls WriteObject and T must be a trivially copyable object.
|
||||||
|
*
|
||||||
|
* See WriteSpan for more details if T is a contiguous container.
|
||||||
|
* See WriteObject for more details if T is a trivially copyable object.
|
||||||
|
*
|
||||||
|
* @tparam T Contiguous container or trivially copyable 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.
|
||||||
|
*/
|
||||||
|
template <typename T>
|
||||||
|
[[nodiscard]] size_t Write(const T& data) const {
|
||||||
|
if constexpr (IsContiguousContainer<T>) {
|
||||||
|
using ContiguousType = typename T::value_type;
|
||||||
|
static_assert(std::is_trivially_copyable_v<ContiguousType>,
|
||||||
|
"Data type must be trivially copyable.");
|
||||||
|
return WriteSpan<ContiguousType>(data);
|
||||||
|
} else {
|
||||||
|
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
|
||||||
|
return WriteObject(data) ? 1 : 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Reads a span of T data from a file sequentially.
|
||||||
|
* This function reads from the current position of the file pointer and
|
||||||
|
* advances it by the (count of T * sizeof(T)) bytes successfully read.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - The file is not open
|
||||||
|
* - The opened file lacks read permissions
|
||||||
|
* - Attempting to read beyond the end-of-file
|
||||||
|
*
|
||||||
|
* @tparam T Data type
|
||||||
|
*
|
||||||
|
* @param data Span of T data
|
||||||
|
*
|
||||||
|
* @returns Count of T data successfully read.
|
||||||
|
*/
|
||||||
|
template <typename T>
|
||||||
|
[[nodiscard]] size_t ReadSpan(std::span<T> data) const {
|
||||||
|
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
|
||||||
|
|
||||||
|
if (!IsOpen()) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return std::fread(data.data(), sizeof(T), data.size(), file);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Writes a span of T data to a file sequentially.
|
||||||
|
* This function writes from the current position of the file pointer and
|
||||||
|
* advances it by the (count of T * sizeof(T)) bytes successfully written.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - The file is not open
|
||||||
|
* - The opened file lacks write permissions
|
||||||
|
*
|
||||||
|
* @tparam T Data type
|
||||||
|
*
|
||||||
|
* @param data Span of T data
|
||||||
|
*
|
||||||
|
* @returns Count of T data successfully written.
|
||||||
|
*/
|
||||||
|
template <typename T>
|
||||||
|
[[nodiscard]] size_t WriteSpan(std::span<const T> data) const {
|
||||||
|
static_assert(std::is_trivially_copyable_v<T>, "Data type must be trivially copyable.");
|
||||||
|
|
||||||
|
if (!IsOpen()) {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return std::fwrite(data.data(), sizeof(T), data.size(), file);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Reads a T object from a file sequentially.
|
||||||
|
* This function reads from the current position of the file pointer and
|
||||||
|
* advances it by the sizeof(T) bytes successfully read.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - The file is not open
|
||||||
|
* - The opened file lacks read permissions
|
||||||
|
* - Attempting to read beyond the end-of-file
|
||||||
|
*
|
||||||
|
* @tparam T Data type
|
||||||
|
*
|
||||||
|
* @param object Reference to object
|
||||||
|
*
|
||||||
|
* @returns True if the object is successfully read from the file, false otherwise.
|
||||||
|
*/
|
||||||
|
template <typename T>
|
||||||
|
[[nodiscard]] bool ReadObject(T& object) const {
|
||||||
|
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.");
|
||||||
|
|
||||||
|
if (!IsOpen()) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return std::fread(&object, sizeof(T), 1, file) == 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Writes a T object to a file sequentially.
|
||||||
|
* This function writes from the current position of the file pointer and
|
||||||
|
* advances it by the sizeof(T) bytes successfully written.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - The file is not open
|
||||||
|
* - The opened file lacks write permissions
|
||||||
|
*
|
||||||
|
* @tparam T Data type
|
||||||
|
*
|
||||||
|
* @param object Const reference to object
|
||||||
|
*
|
||||||
|
* @returns True if the object is successfully written to the file, false otherwise.
|
||||||
|
*/
|
||||||
|
template <typename T>
|
||||||
|
[[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_pointer_v<T>, "T must not be a pointer to an object.");
|
||||||
|
|
||||||
|
if (!IsOpen()) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return std::fwrite(&object, sizeof(T), 1, file) == 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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
|
||||||
|
* 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.
|
||||||
|
*
|
||||||
|
* @param length Length of the string
|
||||||
|
*
|
||||||
|
* @returns A string read from the file.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::string ReadString(size_t length) const;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Specialized function to write a string to a file sequentially.
|
||||||
|
* This function writes from the current position of the file pointer and
|
||||||
|
* advances it by the number of characters successfully written.
|
||||||
|
*
|
||||||
|
* @param string Span of const char backed std::string or std::string_view
|
||||||
|
*
|
||||||
|
* @returns Number of characters successfully written.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] size_t WriteString(std::span<const char> string) const;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Attempts to flush any unwritten buffered data into the file.
|
||||||
|
*
|
||||||
|
* @returns True if the flush was successful, false otherwise.
|
||||||
|
*/
|
||||||
|
bool Flush() const;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Attempts to commit the file into the disk.
|
||||||
|
* 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.
|
||||||
|
*
|
||||||
|
* @returns True if the commit was successful, false otherwise.
|
||||||
|
*/
|
||||||
|
bool Commit() const;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* 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 larger size, the new area appears as if zero-filled.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - The file is not open
|
||||||
|
*
|
||||||
|
* @param size File size in bytes
|
||||||
|
*
|
||||||
|
* @returns True if the file resize succeeded, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool SetSize(u64 size) const;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the size of the file.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - The file is not open
|
||||||
|
*
|
||||||
|
* @returns The file size in bytes of the file. Returns 0 on failure.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] u64 GetSize() const;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Moves the current position of the file pointer with the specified offset and seek origin.
|
||||||
|
*
|
||||||
|
* @param offset Offset from seek origin
|
||||||
|
* @param origin Seek origin
|
||||||
|
*
|
||||||
|
* @returns True if the file pointer has moved to the specified offset, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool Seek(s64 offset, SeekOrigin origin = SeekOrigin::SetOrigin) const;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the current position of the file pointer.
|
||||||
|
*
|
||||||
|
* @returns The current position of the file pointer.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] s64 Tell() const;
|
||||||
|
|
||||||
|
private:
|
||||||
|
std::filesystem::path file_path;
|
||||||
|
FileAccessMode file_access_mode{};
|
||||||
|
FileType file_type{};
|
||||||
|
|
||||||
|
std::FILE* file = nullptr;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace Common::FS
|
||||||
624
src/common/fs/fs.cpp
Normal file
624
src/common/fs/fs.cpp
Normal file
@ -0,0 +1,624 @@
|
|||||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#include "common/fs/file.h"
|
||||||
|
#include "common/fs/fs.h"
|
||||||
|
#include "common/fs/path_util.h"
|
||||||
|
#include "common/logging/log.h"
|
||||||
|
|
||||||
|
namespace Common::FS {
|
||||||
|
|
||||||
|
namespace fs = std::filesystem;
|
||||||
|
|
||||||
|
// File Operations
|
||||||
|
|
||||||
|
bool NewFile(const fs::path& path, u64 size) {
|
||||||
|
if (!ValidatePath(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!Exists(path.parent_path())) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Parent directory of path={} does not exist",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (Exists(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} exists", PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
IOFile io_file{path, FileAccessMode::Write};
|
||||||
|
|
||||||
|
if (!io_file.IsOpen()) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to create a file at path={}", PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!io_file.SetSize(size)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to resize the file at path={} to size={}",
|
||||||
|
PathToUTF8String(path), size);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
io_file.Close();
|
||||||
|
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Successfully created a file at path={} with size={}",
|
||||||
|
PathToUTF8String(path), size);
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool RemoveFile(const fs::path& path) {
|
||||||
|
if (!ValidatePath(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!Exists(path)) {
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!IsFile(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a file",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
fs::remove(path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to remove the file at path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Successfully removed the file at path={}",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool RenameFile(const fs::path& old_path, const fs::path& new_path) {
|
||||||
|
if (!ValidatePath(old_path) || !ValidatePath(new_path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"One or both input path(s) is not valid, old_path={}, new_path={}",
|
||||||
|
PathToUTF8String(old_path), PathToUTF8String(new_path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!Exists(old_path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} does not exist",
|
||||||
|
PathToUTF8String(old_path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!IsFile(old_path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} is not a file",
|
||||||
|
PathToUTF8String(old_path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (Exists(new_path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at new_path={} exists",
|
||||||
|
PathToUTF8String(new_path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
fs::rename(old_path, new_path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to rename the file from old_path={} to new_path={}, ec_message={}",
|
||||||
|
PathToUTF8String(old_path), PathToUTF8String(new_path), ec.message());
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Successfully renamed the file from old_path={} to new_path={}",
|
||||||
|
PathToUTF8String(old_path), PathToUTF8String(new_path));
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::shared_ptr<IOFile> FileOpen(const fs::path& path, FileAccessMode mode, FileType type,
|
||||||
|
FileShareFlag flag) {
|
||||||
|
if (!ValidatePath(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (Exists(path) && !IsFile(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Filesystem object at path={} exists and is not a regular file",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
auto io_file = std::make_shared<IOFile>(path, mode, type, flag);
|
||||||
|
|
||||||
|
if (!io_file->IsOpen()) {
|
||||||
|
io_file.reset();
|
||||||
|
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to open the file at path={} with mode={}, type={}, flag={}",
|
||||||
|
PathToUTF8String(path), mode, type, flag);
|
||||||
|
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG_DEBUG(Common_Filesystem,
|
||||||
|
"Successfully opened the file at path={} with mode={}, type={}, flag={}",
|
||||||
|
PathToUTF8String(path), mode, type, flag);
|
||||||
|
|
||||||
|
return io_file;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Directory Operations
|
||||||
|
|
||||||
|
bool CreateDir(const fs::path& path) {
|
||||||
|
if (!ValidatePath(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!Exists(path.parent_path())) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Parent directory of path={} does not exist",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (IsDir(path)) {
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} exists and is a directory",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
fs::create_directory(path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to create the directory at path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Successfully created the directory at path={}",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool CreateDirs(const fs::path& path) {
|
||||||
|
if (!ValidatePath(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (IsDir(path)) {
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} exists and is a directory",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
fs::create_directories(path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to create the directories at path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Successfully created the directories at path={}",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool CreateParentDir(const fs::path& path) {
|
||||||
|
return CreateDir(path.parent_path());
|
||||||
|
}
|
||||||
|
|
||||||
|
bool CreateParentDirs(const fs::path& path) {
|
||||||
|
return CreateDirs(path.parent_path());
|
||||||
|
}
|
||||||
|
|
||||||
|
bool RemoveDir(const fs::path& path) {
|
||||||
|
if (!ValidatePath(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!Exists(path)) {
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!IsDir(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
fs::remove(path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to remove the directory at path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Successfully removed the directory at path={}",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool RemoveDirRecursively(const fs::path& path) {
|
||||||
|
if (!ValidatePath(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!Exists(path)) {
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!IsDir(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
fs::remove_all(path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to remove the directory and its contents at path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Successfully removed the directory and its contents at path={}",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool RemoveDirContentsRecursively(const fs::path& path) {
|
||||||
|
if (!ValidatePath(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!Exists(path)) {
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} does not exist",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!IsDir(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
// TODO (Morph): Replace this with recursive_directory_iterator once it's fixed in MSVC.
|
||||||
|
for (const auto& entry : fs::directory_iterator(path, ec)) {
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to completely enumerate the directory at path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
fs::remove(entry.path(), ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to remove the filesystem object at path={}, ec_message={}",
|
||||||
|
PathToUTF8String(entry.path()), ec.message());
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO (Morph): Remove this when MSVC fixes recursive_directory_iterator.
|
||||||
|
// recursive_directory_iterator throws an exception despite passing in a std::error_code.
|
||||||
|
if (entry.status().type() == fs::file_type::directory) {
|
||||||
|
return RemoveDirContentsRecursively(entry.path());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to remove all the contents of the directory at path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG_DEBUG(Common_Filesystem,
|
||||||
|
"Successfully removed all the contents of the directory at path={}",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool RenameDir(const fs::path& old_path, const fs::path& new_path) {
|
||||||
|
if (!ValidatePath(old_path) || !ValidatePath(new_path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"One or both input path(s) is not valid, old_path={}, new_path={}",
|
||||||
|
PathToUTF8String(old_path), PathToUTF8String(new_path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!Exists(old_path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} does not exist",
|
||||||
|
PathToUTF8String(old_path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!IsDir(old_path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at old_path={} is not a directory",
|
||||||
|
PathToUTF8String(old_path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (Exists(new_path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at new_path={} exists",
|
||||||
|
PathToUTF8String(new_path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
fs::rename(old_path, new_path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to rename the file from old_path={} to new_path={}, ec_message={}",
|
||||||
|
PathToUTF8String(old_path), PathToUTF8String(new_path), ec.message());
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Successfully renamed the file from old_path={} to new_path={}",
|
||||||
|
PathToUTF8String(old_path), PathToUTF8String(new_path));
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void IterateDirEntries(const std::filesystem::path& path, const DirEntryCallable& callback,
|
||||||
|
DirEntryFilter filter) {
|
||||||
|
if (!ValidatePath(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!Exists(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} does not exist",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!IsDir(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool callback_error = false;
|
||||||
|
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
for (const auto& entry : fs::directory_iterator(path, ec)) {
|
||||||
|
if (ec) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (True(filter & DirEntryFilter::File) &&
|
||||||
|
entry.status().type() == fs::file_type::regular) {
|
||||||
|
if (!callback(entry.path())) {
|
||||||
|
callback_error = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (True(filter & DirEntryFilter::Directory) &&
|
||||||
|
entry.status().type() == fs::file_type::directory) {
|
||||||
|
if (!callback(entry.path())) {
|
||||||
|
callback_error = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (callback_error || ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to visit all the directory entries of path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Successfully visited all the directory entries of path={}",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
}
|
||||||
|
|
||||||
|
void IterateDirEntriesRecursively(const std::filesystem::path& path,
|
||||||
|
const DirEntryCallable& callback, DirEntryFilter filter) {
|
||||||
|
if (!ValidatePath(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is not valid, path={}", PathToUTF8String(path));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!Exists(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} does not exist",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!IsDir(path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at path={} is not a directory",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool callback_error = false;
|
||||||
|
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
// TODO (Morph): Replace this with recursive_directory_iterator once it's fixed in MSVC.
|
||||||
|
for (const auto& entry : fs::directory_iterator(path, ec)) {
|
||||||
|
if (ec) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (True(filter & DirEntryFilter::File) &&
|
||||||
|
entry.status().type() == fs::file_type::regular) {
|
||||||
|
if (!callback(entry.path())) {
|
||||||
|
callback_error = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (True(filter & DirEntryFilter::Directory) &&
|
||||||
|
entry.status().type() == fs::file_type::directory) {
|
||||||
|
if (!callback(entry.path())) {
|
||||||
|
callback_error = true;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO (Morph): Remove this when MSVC fixes recursive_directory_iterator.
|
||||||
|
// recursive_directory_iterator throws an exception despite passing in a std::error_code.
|
||||||
|
if (entry.status().type() == fs::file_type::directory) {
|
||||||
|
IterateDirEntriesRecursively(entry.path(), callback, filter);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (callback_error || ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to visit all the directory entries of path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG_DEBUG(Common_Filesystem, "Successfully visited all the directory entries of path={}",
|
||||||
|
PathToUTF8String(path));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Generic Filesystem Operations
|
||||||
|
|
||||||
|
bool Exists(const fs::path& path) {
|
||||||
|
return fs::exists(path);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IsFile(const fs::path& path) {
|
||||||
|
return fs::is_regular_file(path);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IsDir(const fs::path& path) {
|
||||||
|
return fs::is_directory(path);
|
||||||
|
}
|
||||||
|
|
||||||
|
fs::path GetCurrentDir() {
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
const auto current_path = fs::current_path(ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to get the current path, ec_message={}", ec.message());
|
||||||
|
return {};
|
||||||
|
}
|
||||||
|
|
||||||
|
return current_path;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool SetCurrentDir(const fs::path& path) {
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
fs::current_path(path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to set the current path to path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
fs::file_type GetEntryType(const fs::path& path) {
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
const auto file_status = fs::status(path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to retrieve the entry type of path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return fs::file_type::not_found;
|
||||||
|
}
|
||||||
|
|
||||||
|
return file_status.type();
|
||||||
|
}
|
||||||
|
|
||||||
|
u64 GetSize(const fs::path& path) {
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
const auto file_size = fs::file_size(path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to retrieve the file size of path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return file_size;
|
||||||
|
}
|
||||||
|
|
||||||
|
u64 GetFreeSpaceSize(const fs::path& path) {
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
const auto space_info = fs::space(path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to retrieve the available free space of path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return space_info.free;
|
||||||
|
}
|
||||||
|
|
||||||
|
u64 GetTotalSpaceSize(const fs::path& path) {
|
||||||
|
std::error_code ec;
|
||||||
|
|
||||||
|
const auto space_info = fs::space(path, ec);
|
||||||
|
|
||||||
|
if (ec) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to retrieve the total capacity of path={}, ec_message={}",
|
||||||
|
PathToUTF8String(path), ec.message());
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
return space_info.capacity;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace Common::FS
|
||||||
583
src/common/fs/fs.h
Normal file
583
src/common/fs/fs.h
Normal file
@ -0,0 +1,583 @@
|
|||||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <filesystem>
|
||||||
|
#include <memory>
|
||||||
|
|
||||||
|
#include "common/fs/fs_types.h"
|
||||||
|
#include "common/fs/fs_util.h"
|
||||||
|
|
||||||
|
namespace Common::FS {
|
||||||
|
|
||||||
|
class IOFile;
|
||||||
|
|
||||||
|
// File Operations
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Creates a new file at path with the specified size.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - Input path is not valid
|
||||||
|
* - The input path's parent directory does not exist
|
||||||
|
* - Filesystem object at path exists
|
||||||
|
* - Filesystem at path is read only
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
* @param size File size
|
||||||
|
*
|
||||||
|
* @returns True if the file creation succeeds, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool NewFile(const std::filesystem::path& path, u64 size = 0);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] bool NewFile(const Path& path, u64 size = 0) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return NewFile(ToU8String(path), size);
|
||||||
|
} else {
|
||||||
|
return NewFile(std::filesystem::path{path}, size);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Removes a file at path.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - Input path is not valid
|
||||||
|
* - Filesystem object at path is not a regular file
|
||||||
|
* - Filesystem at path is read only
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if file removal succeeds or file does not exist, false otherwise.
|
||||||
|
*/
|
||||||
|
bool RemoveFile(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
bool RemoveFile(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return RemoveFile(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return RemoveFile(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Renames a file from old_path to new_path.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - One or both input path(s) is not valid
|
||||||
|
* - Filesystem object at old_path does not exist
|
||||||
|
* - Filesystem object at old_path is not a regular file
|
||||||
|
* - Filesystem object at new_path exists
|
||||||
|
* - Filesystem at either path is read only
|
||||||
|
*
|
||||||
|
* @param old_path Old filesystem path
|
||||||
|
* @param new_path New filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if file rename succeeds, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool RenameFile(const std::filesystem::path& old_path,
|
||||||
|
const std::filesystem::path& new_path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path1, typename Path2>
|
||||||
|
[[nodiscard]] bool RenameFile(const Path1& old_path, const Path2& new_path) {
|
||||||
|
using ValueType1 = typename Path1::value_type;
|
||||||
|
using ValueType2 = typename Path2::value_type;
|
||||||
|
if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
|
||||||
|
return RenameFile(ToU8String(old_path), ToU8String(new_path));
|
||||||
|
} else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
|
||||||
|
return RenameFile(ToU8String(old_path), new_path);
|
||||||
|
} else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
|
||||||
|
return RenameFile(old_path, ToU8String(new_path));
|
||||||
|
} else {
|
||||||
|
return RenameFile(std::filesystem::path{old_path}, std::filesystem::path{new_path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Opens a file at path with the specified file access mode.
|
||||||
|
* This function behaves differently depending on the FileAccessMode.
|
||||||
|
* These behaviors are documented in each enum value of FileAccessMode.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - Input path is not valid
|
||||||
|
* - Filesystem object at path exists and is not a regular file
|
||||||
|
* - The file is not open
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
* @param mode File access mode
|
||||||
|
* @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
|
||||||
|
*
|
||||||
|
* @returns A shared pointer to the opened file. Returns nullptr on failure.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::shared_ptr<IOFile> FileOpen(const std::filesystem::path& path,
|
||||||
|
FileAccessMode mode,
|
||||||
|
FileType type = FileType::BinaryFile,
|
||||||
|
FileShareFlag flag = FileShareFlag::ShareReadOnly);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] std::shared_ptr<IOFile> FileOpen(const Path& path, FileAccessMode mode,
|
||||||
|
FileType type = FileType::BinaryFile,
|
||||||
|
FileShareFlag flag = FileShareFlag::ShareReadOnly) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return FileOpen(ToU8String(path), mode, type, flag);
|
||||||
|
} else {
|
||||||
|
return FileOpen(std::filesystem::path{path}, mode, type, flag);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Directory Operations
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Creates a directory at path.
|
||||||
|
* Note that this function will *always* assume that the input path is a directory. For example,
|
||||||
|
* if the input path is /path/to/directory/file.txt, it will create a directory called "file.txt".
|
||||||
|
* If you intend to create the parent directory of a file, use CreateParentDir instead.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - Input path is not valid
|
||||||
|
* - The input path's parent directory does not exist
|
||||||
|
* - Filesystem at path is read only
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if directory creation succeeds or directory already exists, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool CreateDir(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] bool CreateDir(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return CreateDir(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return CreateDir(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Recursively creates a directory at path.
|
||||||
|
* Note that this function will *always* assume that the input path is a directory. For example,
|
||||||
|
* if the input path is /path/to/directory/file.txt, it will create a directory called "file.txt".
|
||||||
|
* If you intend to create the parent directory of a file, use CreateParentDirs instead.
|
||||||
|
* Unlike CreateDir, this creates all of input path's parent directories if they do not exist.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - Input path is not valid
|
||||||
|
* - Filesystem at path is read only
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if directory creation succeeds or directory already exists, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool CreateDirs(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] bool CreateDirs(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return CreateDirs(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return CreateDirs(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Creates the parent directory of a given path.
|
||||||
|
* This function calls CreateDir(path.parent_path()), see CreateDir for more details.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if directory creation succeeds or directory already exists, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool CreateParentDir(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] bool CreateParentDir(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return CreateParentDir(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return CreateParentDir(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Recursively creates the parent directory of a given path.
|
||||||
|
* This function calls CreateDirs(path.parent_path()), see CreateDirs for more details.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if directory creation succeeds or directory already exists, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool CreateParentDirs(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] bool CreateParentDirs(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return CreateParentDirs(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return CreateParentDirs(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Removes a directory at path.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - Input path is not valid
|
||||||
|
* - Filesystem object at path is not a directory
|
||||||
|
* - The given directory is not empty
|
||||||
|
* - Filesystem at path is read only
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if directory removal succeeds or directory does not exist, false otherwise.
|
||||||
|
*/
|
||||||
|
bool RemoveDir(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
bool RemoveDir(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return RemoveDir(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return RemoveDir(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Removes all the contents within the given directory and removes the directory itself.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - Input path is not valid
|
||||||
|
* - Filesystem object at path is not a directory
|
||||||
|
* - Filesystem at path is read only
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if the directory and all of its contents are removed successfully, false otherwise.
|
||||||
|
*/
|
||||||
|
bool RemoveDirRecursively(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
bool RemoveDirRecursively(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return RemoveDirRecursively(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return RemoveDirRecursively(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Removes all the contents within the given directory without removing the directory itself.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - Input path is not valid
|
||||||
|
* - Filesystem object at path is not a directory
|
||||||
|
* - Filesystem at path is read only
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if all of the directory's contents are removed successfully, false otherwise.
|
||||||
|
*/
|
||||||
|
bool RemoveDirContentsRecursively(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
bool RemoveDirContentsRecursively(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return RemoveDirContentsRecursively(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return RemoveDirContentsRecursively(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Renames a directory from old_path to new_path.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - One or both input path(s) is not valid
|
||||||
|
* - Filesystem object at old_path does not exist
|
||||||
|
* - Filesystem object at old_path is not a directory
|
||||||
|
* - Filesystem object at new_path exists
|
||||||
|
* - Filesystem at either path is read only
|
||||||
|
*
|
||||||
|
* @param old_path Old filesystem path
|
||||||
|
* @param new_path New filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if directory rename succeeds, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool RenameDir(const std::filesystem::path& old_path,
|
||||||
|
const std::filesystem::path& new_path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path1, typename Path2>
|
||||||
|
[[nodiscard]] bool RenameDir(const Path1& old_path, const Path2& new_path) {
|
||||||
|
using ValueType1 = typename Path1::value_type;
|
||||||
|
using ValueType2 = typename Path2::value_type;
|
||||||
|
if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
|
||||||
|
return RenameDir(ToU8String(old_path), ToU8String(new_path));
|
||||||
|
} else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
|
||||||
|
return RenameDir(ToU8String(old_path), new_path);
|
||||||
|
} else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
|
||||||
|
return RenameDir(old_path, ToU8String(new_path));
|
||||||
|
} else {
|
||||||
|
return RenameDir(std::filesystem::path{old_path}, std::filesystem::path{new_path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Iterates over the directory entries of a given directory.
|
||||||
|
* This does not iterate over the sub-directories of the given directory.
|
||||||
|
* The DirEntryCallable callback is called for each visited directory entry.
|
||||||
|
* A filter can be set to control which directory entries are visited based on their type.
|
||||||
|
* By default, both files and directories are visited.
|
||||||
|
* If the callback returns false or there is an error, the iteration is immediately halted.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - Input path is not valid
|
||||||
|
* - Filesystem object at path is not a directory
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
* @param callback Callback to be called for each visited directory entry
|
||||||
|
* @param filter Directory entry type filter
|
||||||
|
*/
|
||||||
|
void IterateDirEntries(const std::filesystem::path& path, const DirEntryCallable& callback,
|
||||||
|
DirEntryFilter filter = DirEntryFilter::All);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
void IterateDirEntries(const Path& path, const DirEntryCallable& callback,
|
||||||
|
DirEntryFilter filter = DirEntryFilter::All) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
IterateDirEntries(ToU8String(path), callback, filter);
|
||||||
|
} else {
|
||||||
|
IterateDirEntries(std::filesystem::path{path}, callback, filter);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Iterates over the directory entries of a given directory and its sub-directories.
|
||||||
|
* The DirEntryCallable callback is called for each visited directory entry.
|
||||||
|
* A filter can be set to control which directory entries are visited based on their type.
|
||||||
|
* By default, both files and directories are visited.
|
||||||
|
* If the callback returns false or there is an error, the iteration is immediately halted.
|
||||||
|
*
|
||||||
|
* Failures occur when:
|
||||||
|
* - Input path is not valid
|
||||||
|
* - Filesystem object at path does not exist
|
||||||
|
* - Filesystem object at path is not a directory
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
* @param callback Callback to be called for each visited directory entry
|
||||||
|
* @param filter Directory entry type filter
|
||||||
|
*/
|
||||||
|
void IterateDirEntriesRecursively(const std::filesystem::path& path,
|
||||||
|
const DirEntryCallable& callback,
|
||||||
|
DirEntryFilter filter = DirEntryFilter::All);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
void IterateDirEntriesRecursively(const Path& path, const DirEntryCallable& callback,
|
||||||
|
DirEntryFilter filter = DirEntryFilter::All) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
IterateDirEntriesRecursively(ToU8String(path), callback, filter);
|
||||||
|
} else {
|
||||||
|
IterateDirEntriesRecursively(std::filesystem::path{path}, callback, filter);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Generic Filesystem Operations
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns whether a filesystem object at path exists.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if a filesystem object at path exists, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool Exists(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] bool Exists(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return Exists(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return Exists(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns whether a filesystem object at path is a regular file.
|
||||||
|
* A regular file is a file that stores text or binary data.
|
||||||
|
* It is not a directory, symlink, FIFO, socket, block device, or character device.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if a filesystem object at path is a regular file, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool IsFile(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] bool IsFile(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return IsFile(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return IsFile(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns whether a filesystem object at path is a directory.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if a filesystem object at path is a directory, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool IsDir(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] bool IsDir(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return IsDir(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return IsDir(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the current working directory.
|
||||||
|
*
|
||||||
|
* @returns The current working directory. Returns an empty path on failure.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::filesystem::path GetCurrentDir();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Sets the current working directory to path.
|
||||||
|
*
|
||||||
|
* @returns True if the current working directory is successfully set, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool SetCurrentDir(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] bool SetCurrentDir(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return SetCurrentDir(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return SetCurrentDir(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the entry type of the filesystem object at path.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns The entry type of the filesystem object. Returns file_type::not_found on failure.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::filesystem::file_type GetEntryType(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] std::filesystem::file_type GetEntryType(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return GetEntryType(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return GetEntryType(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the size of the filesystem object at path.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns The size in bytes of the filesystem object. Returns 0 on failure.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] u64 GetSize(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] u64 GetSize(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return GetSize(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return GetSize(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the free space size of the filesystem at path.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns The free space size in bytes of the filesystem at path. Returns 0 on failure.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] u64 GetFreeSpaceSize(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] u64 GetFreeSpaceSize(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return GetFreeSpaceSize(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return GetFreeSpaceSize(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the total capacity of the filesystem at path.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns The total capacity in bytes of the filesystem at path. Returns 0 on failure.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] u64 GetTotalSpaceSize(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] u64 GetTotalSpaceSize(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return GetTotalSpaceSize(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return GetTotalSpaceSize(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
} // namespace Common::FS
|
||||||
25
src/common/fs/fs_paths.h
Normal file
25
src/common/fs/fs_paths.h
Normal file
@ -0,0 +1,25 @@
|
|||||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
// yuzu data directories
|
||||||
|
|
||||||
|
#define CITRA_DIR "citra"
|
||||||
|
#define PORTABLE_DIR "user"
|
||||||
|
|
||||||
|
// Sub-directories contained within a citra data directory
|
||||||
|
|
||||||
|
#define CONFIG_DIR "config"
|
||||||
|
#define CACHE_DIR "cache"
|
||||||
|
#define SDMC_DIR "sdmc"
|
||||||
|
#define NAND_DIR "nand"
|
||||||
|
#define SYSDATA_DIR "sysdata"
|
||||||
|
#define LOG_DIR "log"
|
||||||
|
#define CHEATS_DIR "cheats"
|
||||||
|
#define DLL_DIR "external_dlls"
|
||||||
|
#define SHADER_DIR "shaders"
|
||||||
|
#define DUMP_DIR "dump"
|
||||||
|
#define LOAD_DIR "load"
|
||||||
|
#define SHADER_DIR "shaders"
|
||||||
|
#define STATES_DIR "states"
|
||||||
6
src/common/fs/fs_serialize.cpp
Normal file
6
src/common/fs/fs_serialize.cpp
Normal file
@ -0,0 +1,6 @@
|
|||||||
|
#include "fs_serialize.h"
|
||||||
|
|
||||||
|
fs_serialize::fs_serialize()
|
||||||
|
{
|
||||||
|
|
||||||
|
}
|
||||||
43
src/common/fs/fs_serialize.h
Normal file
43
src/common/fs/fs_serialize.h
Normal file
@ -0,0 +1,43 @@
|
|||||||
|
// Copyright 2022 Citra Emulator Project
|
||||||
|
// Licensed under GPLv2 or any later version
|
||||||
|
// Refer to the license.txt file included.
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <functional>
|
||||||
|
#include <filesystem>
|
||||||
|
#include <boost/serialization/split_member.hpp>
|
||||||
|
#include <boost/serialization/string.hpp>
|
||||||
|
#include <boost/serialization/wrapper.hpp>
|
||||||
|
|
||||||
|
namespace Common::FS {
|
||||||
|
|
||||||
|
// Replaces install-specific paths with standard placeholders, and back again
|
||||||
|
std::filesystem::path SerializePath(const std::filesystem::path& input, bool is_saving);
|
||||||
|
|
||||||
|
// A serializable path string
|
||||||
|
struct Path : public boost::serialization::wrapper_traits<const Path> {
|
||||||
|
std::filesystem::path& path;
|
||||||
|
|
||||||
|
explicit Path(std::filesystem::path& path) : path{path} {}
|
||||||
|
|
||||||
|
static const Path make(std::filesystem::path& path) {
|
||||||
|
return Path(path);
|
||||||
|
}
|
||||||
|
|
||||||
|
template <class Archive>
|
||||||
|
void save(Archive& ar, const unsigned int) const {
|
||||||
|
auto s_path = SerializePath(path, true);
|
||||||
|
ar << s_path;
|
||||||
|
}
|
||||||
|
template <class Archive>
|
||||||
|
void load(Archive& ar, const unsigned int) const {
|
||||||
|
ar >> path;
|
||||||
|
path = SerializePath(path, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
BOOST_SERIALIZATION_SPLIT_MEMBER();
|
||||||
|
friend class boost::serialization::access;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace Common::FS
|
||||||
71
src/common/fs/fs_types.h
Normal file
71
src/common/fs/fs_types.h
Normal file
@ -0,0 +1,71 @@
|
|||||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <functional>
|
||||||
|
#include <filesystem>
|
||||||
|
#include "common/common_funcs.h"
|
||||||
|
|
||||||
|
namespace Common::FS {
|
||||||
|
|
||||||
|
enum class FileAccessMode {
|
||||||
|
/**
|
||||||
|
* If the file at path exists, it opens the file for reading.
|
||||||
|
* If the file at path does not exist, it fails to open the file.
|
||||||
|
*/
|
||||||
|
Read = 1 << 0,
|
||||||
|
/**
|
||||||
|
* If the file at path exists, the existing contents of the file are erased.
|
||||||
|
* The empty file is then opened for writing.
|
||||||
|
* If the file at path does not exist, it creates and opens a new empty file for writing.
|
||||||
|
*/
|
||||||
|
Write = 1 << 1,
|
||||||
|
/**
|
||||||
|
* If the file at path exists, it opens the file for reading and writing.
|
||||||
|
* If the file at path does not exist, it fails to open the file.
|
||||||
|
*/
|
||||||
|
ReadWrite = Read | Write,
|
||||||
|
/**
|
||||||
|
* If the file at path exists, it opens the file for appending.
|
||||||
|
* If the file at path does not exist, it creates and opens a new empty file for appending.
|
||||||
|
*/
|
||||||
|
Append = 1 << 2,
|
||||||
|
/**
|
||||||
|
* If the file at path exists, it opens the file for both reading and appending.
|
||||||
|
* If the file at path does not exist, it creates and opens a new empty file for both
|
||||||
|
* reading and appending.
|
||||||
|
*/
|
||||||
|
ReadAppend = Read | Append,
|
||||||
|
};
|
||||||
|
|
||||||
|
enum class FileType {
|
||||||
|
BinaryFile,
|
||||||
|
TextFile,
|
||||||
|
};
|
||||||
|
|
||||||
|
enum class FileShareFlag {
|
||||||
|
ShareNone, // Provides exclusive access to the file.
|
||||||
|
ShareReadOnly, // Provides read only shared access to the file.
|
||||||
|
ShareWriteOnly, // Provides write only shared access to the file.
|
||||||
|
ShareReadWrite, // Provides read and write shared access to the file.
|
||||||
|
};
|
||||||
|
|
||||||
|
enum class DirEntryFilter {
|
||||||
|
File = 1 << 0,
|
||||||
|
Directory = 1 << 1,
|
||||||
|
All = File | Directory,
|
||||||
|
};
|
||||||
|
DECLARE_ENUM_FLAG_OPERATORS(DirEntryFilter);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* A callback function which takes in the path of a directory entry.
|
||||||
|
*
|
||||||
|
* @param path The path of a directory entry
|
||||||
|
*
|
||||||
|
* @returns A boolean value.
|
||||||
|
* Return true to indicate whether the callback is successful, false otherwise.
|
||||||
|
*/
|
||||||
|
using DirEntryCallable = std::function<bool(const std::filesystem::path& path)>;
|
||||||
|
|
||||||
|
} // namespace Common::FS
|
||||||
38
src/common/fs/fs_util.cpp
Normal file
38
src/common/fs/fs_util.cpp
Normal file
@ -0,0 +1,38 @@
|
|||||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
|
#include "common/fs/fs_util.h"
|
||||||
|
|
||||||
|
namespace Common::FS {
|
||||||
|
|
||||||
|
std::u8string ToU8String(std::string_view utf8_string) {
|
||||||
|
return std::u8string{utf8_string.begin(), utf8_string.end()};
|
||||||
|
}
|
||||||
|
|
||||||
|
std::u8string BufferToU8String(std::span<const u8> buffer) {
|
||||||
|
return std::u8string{buffer.begin(), std::ranges::find(buffer, u8{0})};
|
||||||
|
}
|
||||||
|
|
||||||
|
std::u8string_view BufferToU8StringView(std::span<const u8> buffer) {
|
||||||
|
return std::u8string_view{reinterpret_cast<const char8_t*>(buffer.data())};
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string ToUTF8String(std::u8string_view u8_string) {
|
||||||
|
return std::string{u8_string.begin(), u8_string.end()};
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string BufferToUTF8String(std::span<const u8> buffer) {
|
||||||
|
return std::string{buffer.begin(), std::ranges::find(buffer, u8{0})};
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string_view BufferToUTF8StringView(std::span<const u8> buffer) {
|
||||||
|
return std::string_view{reinterpret_cast<const char*>(buffer.data())};
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string PathToUTF8String(const std::filesystem::path& path) {
|
||||||
|
return ToUTF8String(path.u8string());
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace Common::FS
|
||||||
85
src/common/fs/fs_util.h
Normal file
85
src/common/fs/fs_util.h
Normal file
@ -0,0 +1,85 @@
|
|||||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <concepts>
|
||||||
|
#include <filesystem>
|
||||||
|
#include <span>
|
||||||
|
#include <string>
|
||||||
|
|
||||||
|
#include "common/common_types.h"
|
||||||
|
|
||||||
|
namespace Common::FS {
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
concept IsChar = std::same_as<T, char>;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Converts a UTF-8 encoded std::string or std::string_view to a std::u8string.
|
||||||
|
*
|
||||||
|
* @param utf8_string UTF-8 encoded string
|
||||||
|
*
|
||||||
|
* @returns UTF-8 encoded std::u8string.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::u8string ToU8String(std::string_view utf8_string);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Converts a buffer of bytes to a UTF8-encoded std::u8string.
|
||||||
|
* This converts from the start of the buffer until the first encountered null-terminator.
|
||||||
|
* If no null-terminator is found, this converts the entire buffer instead.
|
||||||
|
*
|
||||||
|
* @param buffer Buffer of bytes
|
||||||
|
*
|
||||||
|
* @returns UTF-8 encoded std::u8string.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::u8string BufferToU8String(std::span<const u8> buffer);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Same as BufferToU8String, but returns a string view of the buffer.
|
||||||
|
*
|
||||||
|
* @param buffer Buffer of bytes
|
||||||
|
*
|
||||||
|
* @returns UTF-8 encoded std::u8string_view.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::u8string_view BufferToU8StringView(std::span<const u8> buffer);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Converts a std::u8string or std::u8string_view to a UTF-8 encoded std::string.
|
||||||
|
*
|
||||||
|
* @param u8_string UTF-8 encoded u8string
|
||||||
|
*
|
||||||
|
* @returns UTF-8 encoded std::string.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::string ToUTF8String(std::u8string_view u8_string);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Converts a buffer of bytes to a UTF8-encoded std::string.
|
||||||
|
* This converts from the start of the buffer until the first encountered null-terminator.
|
||||||
|
* If no null-terminator is found, this converts the entire buffer instead.
|
||||||
|
*
|
||||||
|
* @param buffer Buffer of bytes
|
||||||
|
*
|
||||||
|
* @returns UTF-8 encoded std::string.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::string BufferToUTF8String(std::span<const u8> buffer);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Same as BufferToUTF8String, but returns a string view of the buffer.
|
||||||
|
*
|
||||||
|
* @param buffer Buffer of bytes
|
||||||
|
*
|
||||||
|
* @returns UTF-8 encoded std::string_view.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::string_view BufferToUTF8StringView(std::span<const u8> buffer);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Converts a filesystem path to a UTF-8 encoded std::string.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns UTF-8 encoded std::string.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::string PathToUTF8String(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
} // namespace Common::FS
|
||||||
428
src/common/fs/path_util.cpp
Normal file
428
src/common/fs/path_util.cpp
Normal file
@ -0,0 +1,428 @@
|
|||||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
#include <unordered_map>
|
||||||
|
|
||||||
|
#include "common/fs/fs.h"
|
||||||
|
#include "common/fs/fs_paths.h"
|
||||||
|
#include "common/fs/path_util.h"
|
||||||
|
#include "common/logging/log.h"
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
#include <shlobj.h> // Used in GetExeDirectory()
|
||||||
|
#else
|
||||||
|
#include <cstdlib> // Used in Get(Home/Data)Directory()
|
||||||
|
#include <pwd.h> // Used in GetHomeDirectory()
|
||||||
|
#include <sys/types.h> // Used in GetHomeDirectory()
|
||||||
|
#include <unistd.h> // Used in GetDataDirectory()
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __APPLE__
|
||||||
|
#include <sys/param.h> // Used in GetBundleDirectory()
|
||||||
|
|
||||||
|
// CFURL contains __attribute__ directives that gcc does not know how to parse, so we need to just
|
||||||
|
// ignore them if we're not using clang. The macro is only used to prevent linking against
|
||||||
|
// functions that don't exist on older versions of macOS, and the worst case scenario is a linker
|
||||||
|
// error, so this is perfectly safe, just inconvenient.
|
||||||
|
#ifndef __clang__
|
||||||
|
#define availability(...)
|
||||||
|
#endif
|
||||||
|
#include <CoreFoundation/CFBundle.h> // Used in GetBundleDirectory()
|
||||||
|
#include <CoreFoundation/CFString.h> // Used in GetBundleDirectory()
|
||||||
|
#include <CoreFoundation/CFURL.h> // Used in GetBundleDirectory()
|
||||||
|
#ifdef availability
|
||||||
|
#undef availability
|
||||||
|
#endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef MAX_PATH
|
||||||
|
#ifdef _WIN32
|
||||||
|
// This is the maximum number of UTF-16 code units permissible in Windows file paths
|
||||||
|
#define MAX_PATH 260
|
||||||
|
#else
|
||||||
|
// This is the maximum number of UTF-8 code units permissible in all other OSes' file paths
|
||||||
|
#define MAX_PATH 1024
|
||||||
|
#endif
|
||||||
|
#endif
|
||||||
|
|
||||||
|
namespace Common::FS {
|
||||||
|
|
||||||
|
namespace fs = std::filesystem;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The PathManagerImpl is a singleton allowing to manage the mapping of
|
||||||
|
* UserPath enums to real filesystem paths.
|
||||||
|
* This class provides 2 functions: GetUserPathImpl and SetUserPathImpl.
|
||||||
|
* These are used by GetUserPath and SetUserPath respectively to get or modify
|
||||||
|
* the path mapped by the UserPath enum.
|
||||||
|
*/
|
||||||
|
class PathManagerImpl {
|
||||||
|
public:
|
||||||
|
static PathManagerImpl& GetInstance() {
|
||||||
|
static PathManagerImpl path_manager_impl;
|
||||||
|
|
||||||
|
return path_manager_impl;
|
||||||
|
}
|
||||||
|
|
||||||
|
PathManagerImpl(const PathManagerImpl&) = delete;
|
||||||
|
PathManagerImpl& operator=(const PathManagerImpl&) = delete;
|
||||||
|
|
||||||
|
PathManagerImpl(PathManagerImpl&&) = delete;
|
||||||
|
PathManagerImpl& operator=(PathManagerImpl&&) = delete;
|
||||||
|
|
||||||
|
[[nodiscard]] const fs::path& GetUserPathImpl(UserPath user_path) {
|
||||||
|
return user_paths.at(user_path);
|
||||||
|
}
|
||||||
|
|
||||||
|
void SetUserPathImpl(UserPath user_path, const fs::path& new_path) {
|
||||||
|
user_paths.insert_or_assign(user_path, new_path);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
PathManagerImpl() {
|
||||||
|
fs::path user_path;
|
||||||
|
fs::path user_path_cache;
|
||||||
|
fs::path user_path_config;
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
user_path = GetExeDirectory() / PORTABLE_DIR;
|
||||||
|
|
||||||
|
if (!IsDir(user_path)) {
|
||||||
|
user_path = GetAppDataRoamingDirectory() / CITRA_DIR;
|
||||||
|
}
|
||||||
|
|
||||||
|
user_path_cache = user_path / CACHE_DIR;
|
||||||
|
user_path_config = user_path / CONFIG_DIR;
|
||||||
|
#else
|
||||||
|
user_path = GetCurrentDir() / PORTABLE_DIR;
|
||||||
|
|
||||||
|
if (Exists(user_path) && IsDir(user_path)) {
|
||||||
|
user_path_cache = user_path / CACHE_DIR;
|
||||||
|
user_path_config = user_path / CONFIG_DIR;
|
||||||
|
} else {
|
||||||
|
user_path = GetDataDirectory("XDG_DATA_HOME") / CITRA_DIR;
|
||||||
|
user_path_cache = GetDataDirectory("XDG_CACHE_HOME") / CITRA_DIR;
|
||||||
|
user_path_config = GetDataDirectory("XDG_CONFIG_HOME") / CITRA_DIR;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
GenerateUserPath(UserPath::UserDir, user_path);
|
||||||
|
GenerateUserPath(UserPath::CacheDir, user_path_cache);
|
||||||
|
GenerateUserPath(UserPath::ConfigDir, user_path_config);
|
||||||
|
GenerateUserPath(UserPath::CheatsDir, user_path / CHEATS_DIR);
|
||||||
|
GenerateUserPath(UserPath::DLLDir, user_path / DLL_DIR);
|
||||||
|
GenerateUserPath(UserPath::DumpDir, user_path / DUMP_DIR);
|
||||||
|
GenerateUserPath(UserPath::LoadDir, user_path / LOAD_DIR);
|
||||||
|
GenerateUserPath(UserPath::LogDir, user_path / LOG_DIR);
|
||||||
|
GenerateUserPath(UserPath::NANDDir, user_path / NAND_DIR);
|
||||||
|
GenerateUserPath(UserPath::SDMCDir, user_path / SDMC_DIR);
|
||||||
|
GenerateUserPath(UserPath::SysDataDir, user_path / SYSDATA_DIR);
|
||||||
|
GenerateUserPath(UserPath::StatesDir, user_path / SYSDATA_DIR);
|
||||||
|
GenerateUserPath(UserPath::ShaderDir, user_path / STATES_DIR);
|
||||||
|
}
|
||||||
|
|
||||||
|
~PathManagerImpl() = default;
|
||||||
|
|
||||||
|
void GenerateUserPath(UserPath user_path, const fs::path& new_path) {
|
||||||
|
void(FS::CreateDir(new_path));
|
||||||
|
|
||||||
|
SetUserPathImpl(user_path, new_path);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::unordered_map<UserPath, fs::path> user_paths;
|
||||||
|
};
|
||||||
|
|
||||||
|
bool ValidatePath(const fs::path& path) {
|
||||||
|
if (path.empty()) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is empty, path={}", PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
if (path.u16string().size() >= MAX_PATH) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is too long, path={}", PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
if (path.u8string().size() >= MAX_PATH) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Input path is too long, path={}", PathToUTF8String(path));
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
fs::path ConcatPath(const fs::path& first, const fs::path& second) {
|
||||||
|
const bool second_has_dir_sep = IsDirSeparator(second.u8string().front());
|
||||||
|
|
||||||
|
if (!second_has_dir_sep) {
|
||||||
|
return (first / second).lexically_normal();
|
||||||
|
}
|
||||||
|
|
||||||
|
fs::path concat_path = first;
|
||||||
|
concat_path += second;
|
||||||
|
|
||||||
|
return concat_path.lexically_normal();
|
||||||
|
}
|
||||||
|
|
||||||
|
fs::path ConcatPathSafe(const fs::path& base, const fs::path& offset) {
|
||||||
|
const auto concatenated_path = ConcatPath(base, offset);
|
||||||
|
|
||||||
|
if (!IsPathSandboxed(base, concatenated_path)) {
|
||||||
|
return base;
|
||||||
|
}
|
||||||
|
|
||||||
|
return concatenated_path;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IsPathSandboxed(const fs::path& base, const fs::path& path) {
|
||||||
|
const auto base_string = RemoveTrailingSeparators(base.lexically_normal()).u8string();
|
||||||
|
const auto path_string = RemoveTrailingSeparators(path.lexically_normal()).u8string();
|
||||||
|
|
||||||
|
if (path_string.size() < base_string.size()) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return base_string.compare(0, base_string.size(), path_string, 0, base_string.size()) == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IsDirSeparator(char character) {
|
||||||
|
return character == '/' || character == '\\';
|
||||||
|
}
|
||||||
|
|
||||||
|
bool IsDirSeparator(char8_t character) {
|
||||||
|
return character == u8'/' || character == u8'\\';
|
||||||
|
}
|
||||||
|
|
||||||
|
fs::path RemoveTrailingSeparators(const fs::path& path) {
|
||||||
|
if (path.empty()) {
|
||||||
|
return path;
|
||||||
|
}
|
||||||
|
|
||||||
|
auto string_path = path.u8string();
|
||||||
|
|
||||||
|
while (IsDirSeparator(string_path.back())) {
|
||||||
|
string_path.pop_back();
|
||||||
|
}
|
||||||
|
|
||||||
|
return fs::path{string_path};
|
||||||
|
}
|
||||||
|
|
||||||
|
const fs::path& GetUserPath(UserPath user_path) {
|
||||||
|
return PathManagerImpl::GetInstance().GetUserPathImpl(user_path);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string GetUserPathString(UserPath user_path) {
|
||||||
|
return PathToUTF8String(GetUserPath(user_path));
|
||||||
|
}
|
||||||
|
|
||||||
|
void SetUserPath(UserPath user_path, const fs::path& new_path) {
|
||||||
|
if (!FS::IsDir(new_path)) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Filesystem object at new_path={} is not a directory",
|
||||||
|
PathToUTF8String(new_path));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
PathManagerImpl::GetInstance().SetUserPathImpl(user_path, new_path);
|
||||||
|
}
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
|
||||||
|
fs::path GetExeDirectory() {
|
||||||
|
wchar_t exe_path[MAX_PATH];
|
||||||
|
|
||||||
|
if (GetModuleFileNameW(nullptr, exe_path, MAX_PATH) == 0) {
|
||||||
|
LOG_ERROR(Common_Filesystem,
|
||||||
|
"Failed to get the path to the executable of the current process");
|
||||||
|
}
|
||||||
|
|
||||||
|
return fs::path{exe_path}.parent_path();
|
||||||
|
}
|
||||||
|
|
||||||
|
fs::path GetAppDataRoamingDirectory() {
|
||||||
|
PWSTR appdata_roaming_path = nullptr;
|
||||||
|
|
||||||
|
SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, nullptr, &appdata_roaming_path);
|
||||||
|
|
||||||
|
auto fs_appdata_roaming_path = fs::path{appdata_roaming_path};
|
||||||
|
|
||||||
|
CoTaskMemFree(appdata_roaming_path);
|
||||||
|
|
||||||
|
if (fs_appdata_roaming_path.empty()) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to get the path to the %APPDATA% directory");
|
||||||
|
}
|
||||||
|
|
||||||
|
return fs_appdata_roaming_path;
|
||||||
|
}
|
||||||
|
|
||||||
|
#else
|
||||||
|
|
||||||
|
fs::path GetHomeDirectory() {
|
||||||
|
const char* home_env_var = getenv("HOME");
|
||||||
|
|
||||||
|
if (home_env_var) {
|
||||||
|
return fs::path{home_env_var};
|
||||||
|
}
|
||||||
|
|
||||||
|
LOG_INFO(Common_Filesystem,
|
||||||
|
"$HOME is not defined in the environment variables, "
|
||||||
|
"attempting to query passwd to get the home path of the current user");
|
||||||
|
|
||||||
|
const auto* pw = getpwuid(getuid());
|
||||||
|
|
||||||
|
if (!pw) {
|
||||||
|
LOG_ERROR(Common_Filesystem, "Failed to get the home path of the current user");
|
||||||
|
return {};
|
||||||
|
}
|
||||||
|
|
||||||
|
return fs::path{pw->pw_dir};
|
||||||
|
}
|
||||||
|
|
||||||
|
fs::path GetDataDirectory(const std::string& env_name) {
|
||||||
|
const char* data_env_var = getenv(env_name.c_str());
|
||||||
|
|
||||||
|
if (data_env_var) {
|
||||||
|
return fs::path{data_env_var};
|
||||||
|
}
|
||||||
|
|
||||||
|
if (env_name == "XDG_DATA_HOME") {
|
||||||
|
return GetHomeDirectory() / ".local/share";
|
||||||
|
} else if (env_name == "XDG_CACHE_HOME") {
|
||||||
|
return GetHomeDirectory() / ".cache";
|
||||||
|
} else if (env_name == "XDG_CONFIG_HOME") {
|
||||||
|
return GetHomeDirectory() / ".config";
|
||||||
|
}
|
||||||
|
|
||||||
|
return {};
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __APPLE__
|
||||||
|
|
||||||
|
fs::path GetBundleDirectory() {
|
||||||
|
char app_bundle_path[MAXPATHLEN];
|
||||||
|
|
||||||
|
// Get the main bundle for the app
|
||||||
|
CFURLRef bundle_ref = CFBundleCopyBundleURL(CFBundleGetMainBundle());
|
||||||
|
CFStringRef bundle_path = CFURLCopyFileSystemPath(bundle_ref, kCFURLPOSIXPathStyle);
|
||||||
|
|
||||||
|
CFStringGetFileSystemRepresentation(bundle_path, app_bundle_path, sizeof(app_bundle_path));
|
||||||
|
|
||||||
|
CFRelease(bundle_ref);
|
||||||
|
CFRelease(bundle_path);
|
||||||
|
|
||||||
|
return fs::path{app_bundle_path};
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// vvvvvvvvvv Deprecated vvvvvvvvvv //
|
||||||
|
|
||||||
|
std::string_view RemoveTrailingSlash(std::string_view path) {
|
||||||
|
if (path.empty()) {
|
||||||
|
return path;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (path.back() == '\\' || path.back() == '/') {
|
||||||
|
path.remove_suffix(1);
|
||||||
|
return path;
|
||||||
|
}
|
||||||
|
|
||||||
|
return path;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::vector<std::string> SplitPathComponents(std::string_view filename) {
|
||||||
|
std::string copy(filename);
|
||||||
|
std::replace(copy.begin(), copy.end(), '\\', '/');
|
||||||
|
std::vector<std::string> out;
|
||||||
|
|
||||||
|
std::stringstream stream(copy);
|
||||||
|
std::string item;
|
||||||
|
while (std::getline(stream, item, '/')) {
|
||||||
|
out.push_back(std::move(item));
|
||||||
|
}
|
||||||
|
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string SanitizePath(std::string_view path_, DirectorySeparator directory_separator) {
|
||||||
|
std::string path(path_);
|
||||||
|
char type1 = directory_separator == DirectorySeparator::BackwardSlash ? '/' : '\\';
|
||||||
|
char type2 = directory_separator == DirectorySeparator::BackwardSlash ? '\\' : '/';
|
||||||
|
|
||||||
|
if (directory_separator == DirectorySeparator::PlatformDefault) {
|
||||||
|
#ifdef _WIN32
|
||||||
|
type1 = '/';
|
||||||
|
type2 = '\\';
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
|
std::replace(path.begin(), path.end(), type1, type2);
|
||||||
|
|
||||||
|
auto start = path.begin();
|
||||||
|
#ifdef _WIN32
|
||||||
|
// allow network paths which start with a double backslash (e.g. \\server\share)
|
||||||
|
if (start != path.end())
|
||||||
|
++start;
|
||||||
|
#endif
|
||||||
|
path.erase(std::unique(start, path.end(),
|
||||||
|
[type2](char c1, char c2) { return c1 == type2 && c2 == type2; }),
|
||||||
|
path.end());
|
||||||
|
return std::string(RemoveTrailingSlash(path));
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string_view GetParentPath(std::string_view path) {
|
||||||
|
const auto name_bck_index = path.rfind('\\');
|
||||||
|
const auto name_fwd_index = path.rfind('/');
|
||||||
|
std::size_t name_index;
|
||||||
|
|
||||||
|
if (name_bck_index == std::string_view::npos || name_fwd_index == std::string_view::npos) {
|
||||||
|
name_index = std::min(name_bck_index, name_fwd_index);
|
||||||
|
} else {
|
||||||
|
name_index = std::max(name_bck_index, name_fwd_index);
|
||||||
|
}
|
||||||
|
|
||||||
|
return path.substr(0, name_index);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string_view GetPathWithoutTop(std::string_view path) {
|
||||||
|
if (path.empty()) {
|
||||||
|
return path;
|
||||||
|
}
|
||||||
|
|
||||||
|
while (path[0] == '\\' || path[0] == '/') {
|
||||||
|
path.remove_prefix(1);
|
||||||
|
if (path.empty()) {
|
||||||
|
return path;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
const auto name_bck_index = path.find('\\');
|
||||||
|
const auto name_fwd_index = path.find('/');
|
||||||
|
return path.substr(std::min(name_bck_index, name_fwd_index) + 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string_view GetFilename(std::string_view path) {
|
||||||
|
const auto name_index = path.find_last_of("\\/");
|
||||||
|
|
||||||
|
if (name_index == std::string_view::npos) {
|
||||||
|
return {};
|
||||||
|
}
|
||||||
|
|
||||||
|
return path.substr(name_index + 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::string_view GetExtensionFromFilename(std::string_view name) {
|
||||||
|
const std::size_t index = name.rfind('.');
|
||||||
|
|
||||||
|
if (index == std::string_view::npos) {
|
||||||
|
return {};
|
||||||
|
}
|
||||||
|
|
||||||
|
return name.substr(index + 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace Common::FS
|
||||||
302
src/common/fs/path_util.h
Normal file
302
src/common/fs/path_util.h
Normal file
@ -0,0 +1,302 @@
|
|||||||
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <filesystem>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
#include "common/fs/fs_util.h"
|
||||||
|
|
||||||
|
namespace Common::FS {
|
||||||
|
|
||||||
|
enum class UserPath {
|
||||||
|
CacheDir,
|
||||||
|
CheatsDir,
|
||||||
|
ConfigDir,
|
||||||
|
DLLDir,
|
||||||
|
DumpDir,
|
||||||
|
LoadDir,
|
||||||
|
LogDir,
|
||||||
|
NANDDir,
|
||||||
|
RootDir,
|
||||||
|
SDMCDir,
|
||||||
|
ShaderDir,
|
||||||
|
StatesDir,
|
||||||
|
SysDataDir,
|
||||||
|
UserDir,
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Validates a given path.
|
||||||
|
*
|
||||||
|
* A given path is valid if it meets these conditions:
|
||||||
|
* - The path is not empty
|
||||||
|
* - The path is not too long
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if the path is valid, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool ValidatePath(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] bool ValidatePath(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return ValidatePath(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return ValidatePath(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Concatenates two filesystem paths together.
|
||||||
|
*
|
||||||
|
* This is needed since the following occurs when using std::filesystem::path's operator/:
|
||||||
|
* first: "/first/path"
|
||||||
|
* second: "/second/path" (Note that the second path has a directory separator in the front)
|
||||||
|
* first / second yields "/second/path" when the desired result is first/path/second/path
|
||||||
|
*
|
||||||
|
* @param first First filesystem path
|
||||||
|
* @param second Second filesystem path
|
||||||
|
*
|
||||||
|
* @returns A concatenated filesystem path.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::filesystem::path ConcatPath(const std::filesystem::path& first,
|
||||||
|
const std::filesystem::path& second);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path1, typename Path2>
|
||||||
|
[[nodiscard]] std::filesystem::path ConcatPath(const Path1& first, const Path2& second) {
|
||||||
|
using ValueType1 = typename Path1::value_type;
|
||||||
|
using ValueType2 = typename Path2::value_type;
|
||||||
|
if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
|
||||||
|
return ConcatPath(ToU8String(first), ToU8String(second));
|
||||||
|
} else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
|
||||||
|
return ConcatPath(ToU8String(first), second);
|
||||||
|
} else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
|
||||||
|
return ConcatPath(first, ToU8String(second));
|
||||||
|
} else {
|
||||||
|
return ConcatPath(std::filesystem::path{first}, std::filesystem::path{second});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Safe variant of ConcatPath that takes in a base path and an offset path from the given base path.
|
||||||
|
*
|
||||||
|
* If ConcatPath(base, offset) resolves to a path that is sandboxed within the base path,
|
||||||
|
* this will return the concatenated path. Otherwise this will return the base path.
|
||||||
|
*
|
||||||
|
* @param base Base filesystem path
|
||||||
|
* @param offset Offset filesystem path
|
||||||
|
*
|
||||||
|
* @returns A concatenated filesystem path if it is within the base path,
|
||||||
|
* returns the base path otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::filesystem::path ConcatPathSafe(const std::filesystem::path& base,
|
||||||
|
const std::filesystem::path& offset);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path1, typename Path2>
|
||||||
|
[[nodiscard]] std::filesystem::path ConcatPathSafe(const Path1& base, const Path2& offset) {
|
||||||
|
using ValueType1 = typename Path1::value_type;
|
||||||
|
using ValueType2 = typename Path2::value_type;
|
||||||
|
if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
|
||||||
|
return ConcatPathSafe(ToU8String(base), ToU8String(offset));
|
||||||
|
} else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
|
||||||
|
return ConcatPathSafe(ToU8String(base), offset);
|
||||||
|
} else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
|
||||||
|
return ConcatPathSafe(base, ToU8String(offset));
|
||||||
|
} else {
|
||||||
|
return ConcatPathSafe(std::filesystem::path{base}, std::filesystem::path{offset});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Checks whether a given path is sandboxed within a given base path.
|
||||||
|
*
|
||||||
|
* @param base Base filesystem path
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns True if the given path is sandboxed within the given base path, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool IsPathSandboxed(const std::filesystem::path& base,
|
||||||
|
const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path1, typename Path2>
|
||||||
|
[[nodiscard]] bool IsPathSandboxed(const Path1& base, const Path2& path) {
|
||||||
|
using ValueType1 = typename Path1::value_type;
|
||||||
|
using ValueType2 = typename Path2::value_type;
|
||||||
|
if constexpr (IsChar<ValueType1> && IsChar<ValueType2>) {
|
||||||
|
return IsPathSandboxed(ToU8String(base), ToU8String(path));
|
||||||
|
} else if constexpr (IsChar<ValueType1> && !IsChar<ValueType2>) {
|
||||||
|
return IsPathSandboxed(ToU8String(base), path);
|
||||||
|
} else if constexpr (!IsChar<ValueType1> && IsChar<ValueType2>) {
|
||||||
|
return IsPathSandboxed(base, ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return IsPathSandboxed(std::filesystem::path{base}, std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Checks if a character is a directory separator (either a forward slash or backslash).
|
||||||
|
*
|
||||||
|
* @param character Character
|
||||||
|
*
|
||||||
|
* @returns True if the character is a directory separator, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool IsDirSeparator(char character);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Checks if a character is a directory separator (either a forward slash or backslash).
|
||||||
|
*
|
||||||
|
* @param character Character
|
||||||
|
*
|
||||||
|
* @returns True if the character is a directory separator, false otherwise.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] bool IsDirSeparator(char8_t character);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Removes any trailing directory separators if they exist in the given path.
|
||||||
|
*
|
||||||
|
* @param path Filesystem path
|
||||||
|
*
|
||||||
|
* @returns The filesystem path without any trailing directory separators.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::filesystem::path RemoveTrailingSeparators(const std::filesystem::path& path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
[[nodiscard]] std::filesystem::path RemoveTrailingSeparators(const Path& path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
return RemoveTrailingSeparators(ToU8String(path));
|
||||||
|
} else {
|
||||||
|
return RemoveTrailingSeparators(std::filesystem::path{path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the filesystem path associated with the UserPath enum.
|
||||||
|
*
|
||||||
|
* @param user_path UserPath enum
|
||||||
|
*
|
||||||
|
* @returns The filesystem path associated with the UserPath enum.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] const std::filesystem::path& GetUserPath(UserPath user_path);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the filesystem path associated with the UserPath enum as a UTF-8 encoded std::string.
|
||||||
|
*
|
||||||
|
* @param user_path UserPath enum
|
||||||
|
*
|
||||||
|
* @returns The filesystem path associated with the UserPath enum as a UTF-8 encoded std::string.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::string GetUserPathString(UserPath user_path);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Sets a new filesystem path associated with the User enum.
|
||||||
|
* If the filesystem object at new_path is not a directory, this function will not do anything.
|
||||||
|
*
|
||||||
|
* @param user_path User enum
|
||||||
|
* @param new_path New filesystem path
|
||||||
|
*/
|
||||||
|
void SetUserPath(UserPath user_path, const std::filesystem::path& new_path);
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
template <typename Path>
|
||||||
|
void SetUserPath(UserPath user_path, const Path& new_path) {
|
||||||
|
if constexpr (IsChar<typename Path::value_type>) {
|
||||||
|
SetUserPath(user_path, ToU8String(new_path));
|
||||||
|
} else {
|
||||||
|
SetUserPath(user_path, std::filesystem::path{new_path});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef _WIN32
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the path of the directory containing the executable of the current process.
|
||||||
|
*
|
||||||
|
* @returns The path of the directory containing the executable of the current process.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::filesystem::path GetExeDirectory();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the path of the current user's %APPDATA% directory (%USERPROFILE%/AppData/Roaming).
|
||||||
|
*
|
||||||
|
* @returns The path of the current user's %APPDATA% directory.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::filesystem::path GetAppDataRoamingDirectory();
|
||||||
|
|
||||||
|
#else
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the path of the directory specified by the #HOME environment variable.
|
||||||
|
* If $HOME is not defined, it will attempt to query the user database in passwd instead.
|
||||||
|
*
|
||||||
|
* @returns The path of the current user's home directory.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::filesystem::path GetHomeDirectory();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the relevant paths for yuzu to store its data based on the given XDG environment variable.
|
||||||
|
* See https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
|
||||||
|
* Defaults to $HOME/.local/share for main application data,
|
||||||
|
* $HOME/.cache for cached data, and $HOME/.config for configuration files.
|
||||||
|
*
|
||||||
|
* @param env_name XDG environment variable name
|
||||||
|
*
|
||||||
|
* @returns The path where yuzu should store its data.
|
||||||
|
*/
|
||||||
|
[[nodiscard]] std::filesystem::path GetDataDirectory(const std::string& env_name);
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifdef __APPLE__
|
||||||
|
|
||||||
|
[[nodiscard]] std::filesystem::path GetBundleDirectory();
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// vvvvvvvvvv Deprecated vvvvvvvvvv //
|
||||||
|
|
||||||
|
// Removes the final '/' or '\' if one exists
|
||||||
|
[[nodiscard]] std::string_view RemoveTrailingSlash(std::string_view path);
|
||||||
|
|
||||||
|
enum class DirectorySeparator {
|
||||||
|
ForwardSlash,
|
||||||
|
BackwardSlash,
|
||||||
|
PlatformDefault,
|
||||||
|
};
|
||||||
|
|
||||||
|
// Splits the path on '/' or '\' and put the components into a vector
|
||||||
|
// i.e. "C:\Users\User\Documents\save.bin" becomes {"C:", "Users", "User", "Documents", "save.bin" }
|
||||||
|
[[nodiscard]] std::vector<std::string> SplitPathComponents(std::string_view filename);
|
||||||
|
|
||||||
|
// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
|
||||||
|
// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
|
||||||
|
[[nodiscard]] std::string SanitizePath(
|
||||||
|
std::string_view path,
|
||||||
|
DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);
|
||||||
|
|
||||||
|
// Gets all of the text up to the last '/' or '\' in the path.
|
||||||
|
[[nodiscard]] std::string_view GetParentPath(std::string_view path);
|
||||||
|
|
||||||
|
// Gets all of the text after the first '/' or '\' in the path.
|
||||||
|
[[nodiscard]] std::string_view GetPathWithoutTop(std::string_view path);
|
||||||
|
|
||||||
|
// Gets the filename of the path
|
||||||
|
[[nodiscard]] std::string_view GetFilename(std::string_view path);
|
||||||
|
|
||||||
|
// Gets the extension of the filename
|
||||||
|
[[nodiscard]] std::string_view GetExtensionFromFilename(std::string_view name);
|
||||||
|
|
||||||
|
} // namespace Common::FS
|
||||||
@ -18,6 +18,7 @@
|
|||||||
#define _SH_DENYWR 0
|
#define _SH_DENYWR 0
|
||||||
#endif
|
#endif
|
||||||
#include "common/assert.h"
|
#include "common/assert.h"
|
||||||
|
#include "common/fs/fs.h"
|
||||||
#include "common/logging/backend.h"
|
#include "common/logging/backend.h"
|
||||||
#include "common/logging/log.h"
|
#include "common/logging/log.h"
|
||||||
#include "common/logging/text_formatter.h"
|
#include "common/logging/text_formatter.h"
|
||||||
@ -146,10 +147,10 @@ void LogcatBackend::Write(const Entry& entry) {
|
|||||||
|
|
||||||
FileBackend::FileBackend(const std::string& filename) : bytes_written(0) {
|
FileBackend::FileBackend(const std::string& filename) : bytes_written(0) {
|
||||||
if (Common::FS::Exists(filename + ".old.txt")) {
|
if (Common::FS::Exists(filename + ".old.txt")) {
|
||||||
Common::FS::Delete(filename + ".old.txt");
|
Common::FS::RemoveFile(filename + ".old.txt");
|
||||||
}
|
}
|
||||||
if (Common::FS::Exists(filename)) {
|
if (Common::FS::Exists(filename)) {
|
||||||
Common::FS::Rename(filename, filename + ".old.txt");
|
Common::FS::RenameFile(filename, filename + ".old.txt");
|
||||||
}
|
}
|
||||||
|
|
||||||
// _SH_DENYWR allows read only access to the file for other programs.
|
// _SH_DENYWR allows read only access to the file for other programs.
|
||||||
|
|||||||
@ -8,8 +8,7 @@
|
|||||||
#include <memory>
|
#include <memory>
|
||||||
#include <string>
|
#include <string>
|
||||||
#include <string_view>
|
#include <string_view>
|
||||||
#include "common/file_util.h"
|
#include "common/fs/file.h"
|
||||||
#include "common/logging/filter.h"
|
|
||||||
#include "common/logging/log.h"
|
#include "common/logging/log.h"
|
||||||
|
|
||||||
namespace Log {
|
namespace Log {
|
||||||
|
|||||||
@ -4,7 +4,7 @@
|
|||||||
|
|
||||||
#include <algorithm>
|
#include <algorithm>
|
||||||
#include <set>
|
#include <set>
|
||||||
#include "common/file_util.h"
|
#include "common/fs/fs.h"
|
||||||
#include "common/string_util.h"
|
#include "common/string_util.h"
|
||||||
#include "core/file_sys/path_parser.h"
|
#include "core/file_sys/path_parser.h"
|
||||||
|
|
||||||
@ -59,7 +59,7 @@ PathParser::PathParser(const Path& path) {
|
|||||||
|
|
||||||
PathParser::HostStatus PathParser::GetHostStatus(std::string_view mount_point) const {
|
PathParser::HostStatus PathParser::GetHostStatus(std::string_view mount_point) const {
|
||||||
std::string path{mount_point};
|
std::string path{mount_point};
|
||||||
if (!Common::FS::IsDirectory(path))
|
if (!Common::FS::IsDir(path))
|
||||||
return InvalidMountPoint;
|
return InvalidMountPoint;
|
||||||
if (path_sequence.empty()) {
|
if (path_sequence.empty()) {
|
||||||
return DirectoryFound;
|
return DirectoryFound;
|
||||||
@ -72,7 +72,7 @@ PathParser::HostStatus PathParser::GetHostStatus(std::string_view mount_point) c
|
|||||||
|
|
||||||
if (!Common::FS::Exists(path))
|
if (!Common::FS::Exists(path))
|
||||||
return PathNotFound;
|
return PathNotFound;
|
||||||
if (Common::FS::IsDirectory(path))
|
if (Common::FS::IsDir(path))
|
||||||
continue;
|
continue;
|
||||||
return FileInPath;
|
return FileInPath;
|
||||||
}
|
}
|
||||||
@ -80,7 +80,7 @@ PathParser::HostStatus PathParser::GetHostStatus(std::string_view mount_point) c
|
|||||||
path += "/" + path_sequence.back();
|
path += "/" + path_sequence.back();
|
||||||
if (!Common::FS::Exists(path))
|
if (!Common::FS::Exists(path))
|
||||||
return NotFound;
|
return NotFound;
|
||||||
if (Common::FS::IsDirectory(path))
|
if (Common::FS::IsDir(path))
|
||||||
return DirectoryFound;
|
return DirectoryFound;
|
||||||
return FileFound;
|
return FileFound;
|
||||||
}
|
}
|
||||||
|
|||||||
@ -5,6 +5,7 @@
|
|||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
#include <string>
|
#include <string>
|
||||||
|
#include <string_view>
|
||||||
#include <vector>
|
#include <vector>
|
||||||
#include "core/file_sys/archive_backend.h"
|
#include "core/file_sys/archive_backend.h"
|
||||||
|
|
||||||
|
|||||||
Reference in New Issue
Block a user