mirror of
https://github.com/wheremyfoodat/Panda3DS.git
synced 2025-04-19 20:19:13 +12:00
Refactor Rust::Result into std::expected
The standard library already has support for this type as of C++23: https://en.cppreference.com/w/cpp/header/expected [This is also supported by all major compilers](https://en.cppreference.com/w/cpp/compiler_support#:~:text=Yes-,%3Cexpected%3E,-P0323R12%0AP2549R1)
This commit is contained in:
Wunkolo
parent
57193e7944
commit
3d0a0ccc0b
21 changed files with 349 additions and 1621 deletions
|
|
@ -6,7 +6,7 @@ else()
|
|||
cmake_minimum_required(VERSION 3.10)
|
||||
endif()
|
||||
|
||||
set(CMAKE_CXX_STANDARD 20)
|
||||
set(CMAKE_CXX_STANDARD 23)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED True)
|
||||
|
||||
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 12)
|
||||
|
|
@ -49,7 +49,6 @@ include_directories(third_party/imgui/)
|
|||
include_directories(third_party/dynarmic/src)
|
||||
include_directories(third_party/cryptopp/)
|
||||
include_directories(third_party/cityhash/include)
|
||||
include_directories(third_party/result/include)
|
||||
include_directories(third_party/xxhash/include)
|
||||
include_directories(third_party/httplib)
|
||||
include_directories(third_party/stb)
|
||||
|
|
|
|||
|
|
@ -2,14 +2,15 @@
|
|||
#include <cassert>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <expected>
|
||||
#include <filesystem>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <type_traits>
|
||||
#include <vector>
|
||||
|
||||
#include "helpers.hpp"
|
||||
#include "memory.hpp"
|
||||
#include "result.hpp"
|
||||
#include "result/result.hpp"
|
||||
|
||||
using Result::HorizonResult;
|
||||
|
|
@ -55,7 +56,7 @@ namespace ArchiveID {
|
|||
default: return "Unknown archive";
|
||||
}
|
||||
}
|
||||
}
|
||||
} // namespace ArchiveID
|
||||
|
||||
struct FSPath {
|
||||
u32 type = PathType::Invalid;
|
||||
|
|
@ -68,9 +69,7 @@ struct FSPath {
|
|||
|
||||
FSPath(u32 type, const std::vector<u8>& vec) : type(type) {
|
||||
switch (type) {
|
||||
case PathType::Binary:
|
||||
binary = std::move(vec);
|
||||
break;
|
||||
case PathType::Binary: binary = std::move(vec); break;
|
||||
|
||||
case PathType::ASCII:
|
||||
string.resize(vec.size() - 1); // -1 because of the null terminator
|
||||
|
|
@ -82,8 +81,8 @@ struct FSPath {
|
|||
utf16_string.resize(size);
|
||||
std::memcpy(utf16_string.data(), vec.data(), size * sizeof(u16));
|
||||
break;
|
||||
};
|
||||
}
|
||||
; }
|
||||
}
|
||||
};
|
||||
|
||||
|
|
@ -105,12 +104,12 @@ struct FileSession {
|
|||
u32 priority = 0; // TODO: What does this even do
|
||||
bool isOpen;
|
||||
|
||||
FileSession(ArchiveBase* archive, const FSPath& filePath, const FSPath& archivePath, FILE* fd, bool isOpen = true) :
|
||||
archive(archive), path(filePath), archivePath(archivePath), fd(fd), isOpen(isOpen), priority(0) {}
|
||||
FileSession(ArchiveBase* archive, const FSPath& filePath, const FSPath& archivePath, FILE* fd, bool isOpen = true)
|
||||
: archive(archive), path(filePath), archivePath(archivePath), fd(fd), isOpen(isOpen), priority(0) {}
|
||||
|
||||
// For cloning a file session
|
||||
FileSession(const FileSession& other) : archive(other.archive), path(other.path),
|
||||
archivePath(other.archivePath), fd(other.fd), isOpen(other.isOpen), priority(other.priority) {}
|
||||
FileSession(const FileSession& other)
|
||||
: archive(other.archive), path(other.path), archivePath(other.archivePath), fd(other.fd), isOpen(other.isOpen), priority(other.priority) {}
|
||||
};
|
||||
|
||||
struct ArchiveSession {
|
||||
|
|
@ -156,7 +155,7 @@ struct DirectorySession {
|
|||
using FileDescriptor = std::optional<FILE*>;
|
||||
|
||||
class ArchiveBase {
|
||||
public:
|
||||
public:
|
||||
struct FormatInfo {
|
||||
u32 size; // Archive size
|
||||
u32 numOfDirectories; // Number of directories
|
||||
|
|
@ -164,7 +163,7 @@ public:
|
|||
bool duplicateData; // Whether to duplicate data or not
|
||||
};
|
||||
|
||||
protected:
|
||||
protected:
|
||||
using Handle = u32;
|
||||
|
||||
static constexpr FileDescriptor NoFile = nullptr;
|
||||
|
|
@ -173,8 +172,8 @@ protected:
|
|||
|
||||
// Returns if a specified 3DS path in UTF16 or ASCII format is safe or not
|
||||
// A 3DS path is considered safe if its first character is '/' which means we're not trying to access anything outside the root of the fs
|
||||
// And if it doesn't contain enough instances of ".." (Indicating "climb up a folder" in filesystems) to let the software climb up the directory tree
|
||||
// And access files outside of the emulator's app data folder
|
||||
// And if it doesn't contain enough instances of ".." (Indicating "climb up a folder" in filesystems) to let the software climb up the directory
|
||||
// tree And access files outside of the emulator's app data folder
|
||||
template <u32 format>
|
||||
bool isPathSafe(const FSPath& path) {
|
||||
static_assert(format == PathType::ASCII || format == PathType::UTF16);
|
||||
|
|
@ -216,16 +215,16 @@ protected:
|
|||
return true;
|
||||
}
|
||||
|
||||
public:
|
||||
public:
|
||||
virtual std::string name() = 0;
|
||||
virtual u64 getFreeBytes() = 0;
|
||||
virtual HorizonResult createFile(const FSPath& path, u64 size) = 0;
|
||||
virtual HorizonResult deleteFile(const FSPath& path) = 0;
|
||||
|
||||
virtual Rust::Result<FormatInfo, HorizonResult> getFormatInfo(const FSPath& path) {
|
||||
virtual std::expected<FormatInfo, HorizonResult> getFormatInfo(const FSPath& path) {
|
||||
Helpers::panic("Unimplemented GetFormatInfo for %s archive", name().c_str());
|
||||
// Return a dummy struct just to avoid the UB of not returning anything, even if we panic
|
||||
return Ok(FormatInfo{ .size = 0, .numOfDirectories = 0, .numOfFiles = 0, .duplicateData = false });
|
||||
return FormatInfo{.size = 0, .numOfDirectories = 0, .numOfFiles = 0, .duplicateData = false};
|
||||
}
|
||||
|
||||
virtual HorizonResult createDirectory(const FSPath& path) {
|
||||
|
|
@ -235,16 +234,14 @@ public:
|
|||
|
||||
// Returns nullopt if opening the file failed, otherwise returns a file descriptor to it (nullptr if none is needed)
|
||||
virtual FileDescriptor openFile(const FSPath& path, const FilePerms& perms) = 0;
|
||||
virtual Rust::Result<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) = 0;
|
||||
virtual std::expected<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) = 0;
|
||||
|
||||
virtual Rust::Result<DirectorySession, HorizonResult> openDirectory(const FSPath& path) {
|
||||
virtual std::expected<DirectorySession, HorizonResult> openDirectory(const FSPath& path) {
|
||||
Helpers::panic("Unimplemented OpenDirectory for %s archive", name().c_str());
|
||||
return Err(Result::FS::FileNotFoundAlt);
|
||||
return std::unexpected(Result::FS::FileNotFoundAlt);
|
||||
}
|
||||
|
||||
virtual void format(const FSPath& path, const FormatInfo& info) {
|
||||
Helpers::panic("Unimplemented Format for %s archive", name().c_str());
|
||||
}
|
||||
virtual void format(const FSPath& path, const FormatInfo& info) { Helpers::panic("Unimplemented Format for %s archive", name().c_str()); }
|
||||
|
||||
virtual HorizonResult renameFile(const FSPath& oldPath, const FSPath& newPath) {
|
||||
Helpers::panic("Unimplemented RenameFile for %s archive", name().c_str());
|
||||
|
|
|
|||
|
|
@ -2,11 +2,13 @@
|
|||
#include "archive_base.hpp"
|
||||
|
||||
class ExtSaveDataArchive : public ArchiveBase {
|
||||
public:
|
||||
ExtSaveDataArchive(Memory& mem, const std::string& folder, bool isShared = false) : ArchiveBase(mem),
|
||||
isShared(isShared), backingFolder(folder) {}
|
||||
public:
|
||||
ExtSaveDataArchive(Memory& mem, const std::string& folder, bool isShared = false) : ArchiveBase(mem), isShared(isShared), backingFolder(folder) {}
|
||||
|
||||
u64 getFreeBytes() override { Helpers::panic("ExtSaveData::GetFreeBytes unimplemented"); return 0; }
|
||||
u64 getFreeBytes() override {
|
||||
Helpers::panic("ExtSaveData::GetFreeBytes unimplemented");
|
||||
return 0;
|
||||
}
|
||||
std::string name() override { return "ExtSaveData::" + backingFolder; }
|
||||
|
||||
HorizonResult createDirectory(const FSPath& path) override;
|
||||
|
|
@ -14,14 +16,14 @@ public:
|
|||
HorizonResult deleteFile(const FSPath& path) override;
|
||||
HorizonResult renameFile(const FSPath& oldPath, const FSPath& newPath) override;
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
Rust::Result<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
|
||||
std::expected<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
std::expected<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
|
||||
FileDescriptor openFile(const FSPath& path, const FilePerms& perms) override;
|
||||
std::optional<u32> readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) override;
|
||||
|
||||
Rust::Result<FormatInfo, HorizonResult> getFormatInfo(const FSPath& path) override {
|
||||
std::expected<FormatInfo, HorizonResult> getFormatInfo(const FSPath& path) override {
|
||||
Helpers::warn("Stubbed ExtSaveData::GetFormatInfo");
|
||||
return Ok(FormatInfo{.size = 1_GB, .numOfDirectories = 255, .numOfFiles = 255, .duplicateData = false});
|
||||
return FormatInfo{.size = 1_GB, .numOfDirectories = 255, .numOfFiles = 255, .duplicateData = false};
|
||||
}
|
||||
|
||||
// Takes in a binary ExtSaveData path, outputs a combination of the backing folder with the low and high save entries of the path
|
||||
|
|
|
|||
|
|
@ -2,16 +2,19 @@
|
|||
#include "archive_base.hpp"
|
||||
|
||||
class NCCHArchive : public ArchiveBase {
|
||||
public:
|
||||
public:
|
||||
NCCHArchive(Memory& mem) : ArchiveBase(mem) {}
|
||||
|
||||
u64 getFreeBytes() override { Helpers::panic("NCCH::GetFreeBytes unimplemented"); return 0; }
|
||||
u64 getFreeBytes() override {
|
||||
Helpers::panic("NCCH::GetFreeBytes unimplemented");
|
||||
return 0;
|
||||
}
|
||||
std::string name() override { return "NCCH"; }
|
||||
|
||||
HorizonResult createFile(const FSPath& path, u64 size) override;
|
||||
HorizonResult deleteFile(const FSPath& path) override;
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
std::expected<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
FileDescriptor openFile(const FSPath& path, const FilePerms& perms) override;
|
||||
std::optional<u32> readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) override;
|
||||
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
#include "archive_base.hpp"
|
||||
|
||||
class SaveDataArchive : public ArchiveBase {
|
||||
public:
|
||||
public:
|
||||
SaveDataArchive(Memory& mem) : ArchiveBase(mem) {}
|
||||
|
||||
u64 getFreeBytes() override { return 32_MB; }
|
||||
|
|
@ -12,17 +12,15 @@ public:
|
|||
HorizonResult createFile(const FSPath& path, u64 size) override;
|
||||
HorizonResult deleteFile(const FSPath& path) override;
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
Rust::Result<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
|
||||
std::expected<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
std::expected<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
|
||||
FileDescriptor openFile(const FSPath& path, const FilePerms& perms) override;
|
||||
std::optional<u32> readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) override;
|
||||
|
||||
void format(const FSPath& path, const FormatInfo& info) override;
|
||||
Rust::Result<FormatInfo, HorizonResult> getFormatInfo(const FSPath& path) override;
|
||||
std::expected<FormatInfo, HorizonResult> getFormatInfo(const FSPath& path) override;
|
||||
|
||||
std::filesystem::path getFormatInfoPath() {
|
||||
return IOFile::getAppData() / "FormatInfo" / "SaveData.format";
|
||||
}
|
||||
std::filesystem::path getFormatInfoPath() { return IOFile::getAppData() / "FormatInfo" / "SaveData.format"; }
|
||||
|
||||
// Returns whether the cart has save data or not
|
||||
bool cartHasSaveData() {
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@ class SDMCArchive : public ArchiveBase {
|
|||
HorizonResult deleteFile(const FSPath& path) override;
|
||||
HorizonResult createDirectory(const FSPath& path) override;
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
Rust::Result<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
|
||||
std::expected<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
std::expected<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
|
||||
|
||||
FileDescriptor openFile(const FSPath& path, const FilePerms& perms) override;
|
||||
std::optional<u32> readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) override;
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
#include "archive_base.hpp"
|
||||
|
||||
class SelfNCCHArchive : public ArchiveBase {
|
||||
public:
|
||||
public:
|
||||
SelfNCCHArchive(Memory& mem) : ArchiveBase(mem) {}
|
||||
|
||||
u64 getFreeBytes() override { return 0; }
|
||||
|
|
@ -11,7 +11,7 @@ public:
|
|||
HorizonResult createFile(const FSPath& path, u64 size) override;
|
||||
HorizonResult deleteFile(const FSPath& path) override;
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
std::expected<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
FileDescriptor openFile(const FSPath& path, const FilePerms& perms) override;
|
||||
std::optional<u32> readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) override;
|
||||
|
||||
|
|
|
|||
|
|
@ -16,8 +16,8 @@ class SystemSaveDataArchive : public ArchiveBase {
|
|||
HorizonResult createFile(const FSPath& path, u64 size) override;
|
||||
HorizonResult deleteFile(const FSPath& path) override;
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
Rust::Result<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
|
||||
std::expected<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
std::expected<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
|
||||
|
||||
FileDescriptor openFile(const FSPath& path, const FilePerms& perms) override;
|
||||
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
|
||||
class UserSaveDataArchive : public ArchiveBase {
|
||||
u32 archiveID;
|
||||
|
||||
public:
|
||||
UserSaveDataArchive(Memory& mem, u32 archiveID) : ArchiveBase(mem), archiveID(archiveID) {}
|
||||
|
||||
|
|
@ -13,13 +14,13 @@ class UserSaveDataArchive : public ArchiveBase {
|
|||
HorizonResult createFile(const FSPath& path, u64 size) override;
|
||||
HorizonResult deleteFile(const FSPath& path) override;
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
Rust::Result<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
|
||||
std::expected<ArchiveBase*, HorizonResult> openArchive(const FSPath& path) override;
|
||||
std::expected<DirectorySession, HorizonResult> openDirectory(const FSPath& path) override;
|
||||
FileDescriptor openFile(const FSPath& path, const FilePerms& perms) override;
|
||||
std::optional<u32> readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) override;
|
||||
|
||||
void format(const FSPath& path, const FormatInfo& info) override;
|
||||
Rust::Result<FormatInfo, HorizonResult> getFormatInfo(const FSPath& path) override;
|
||||
std::expected<FormatInfo, HorizonResult> getFormatInfo(const FSPath& path) override;
|
||||
|
||||
std::filesystem::path getFormatInfoPath() { return IOFile::getAppData() / "FormatInfo" / "SaveData.format"; }
|
||||
|
||||
|
|
|
|||
|
|
@ -38,8 +38,8 @@ class FSService {
|
|||
SystemSaveDataArchive systemSaveData;
|
||||
|
||||
ArchiveBase* getArchiveFromID(u32 id, const FSPath& archivePath);
|
||||
Rust::Result<Handle, HorizonResult> openArchiveHandle(u32 archiveID, const FSPath& path);
|
||||
Rust::Result<Handle, HorizonResult> openDirectoryHandle(ArchiveBase* archive, const FSPath& path);
|
||||
std::expected<Handle, HorizonResult> openArchiveHandle(u32 archiveID, const FSPath& path);
|
||||
std::expected<Handle, HorizonResult> openDirectoryHandle(ArchiveBase* archive, const FSPath& path);
|
||||
std::optional<Handle> openFileHandle(ArchiveBase* archive, const FSPath& path, const FSPath& archivePath, const FilePerms& perms);
|
||||
FSPath readPath(u32 type, u32 pointer, u32 size);
|
||||
|
||||
|
|
@ -81,7 +81,7 @@ class FSService {
|
|||
// Used for set/get priority: Not sure what sort of priority this is referring to
|
||||
u32 priority;
|
||||
|
||||
public:
|
||||
public:
|
||||
FSService(Memory& mem, Kernel& kernel, const EmulatorConfig& config)
|
||||
: mem(mem), saveData(mem), sharedExtSaveData_nand(mem, "../SharedFiles/NAND", true), extSaveData_sdmc(mem, "SDMC"), sdmc(mem),
|
||||
sdmcWriteOnly(mem, true), selfNcch(mem), ncch(mem), userSaveData1(mem, ArchiveID::UserSaveData1),
|
||||
|
|
|
|||
|
|
@ -1,21 +1,19 @@
|
|||
#include "fs/archive_ext_save_data.hpp"
|
||||
|
||||
#include <memory>
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
HorizonResult ExtSaveDataArchive::createFile(const FSPath& path, u64 size) {
|
||||
if (size == 0)
|
||||
Helpers::panic("ExtSaveData file does not support size == 0");
|
||||
if (size == 0) Helpers::panic("ExtSaveData file does not support size == 0");
|
||||
|
||||
if (path.type == PathType::UTF16) {
|
||||
if (!isPathSafe<PathType::UTF16>(path))
|
||||
Helpers::panic("Unsafe path in ExtSaveData::CreateFile");
|
||||
if (!isPathSafe<PathType::UTF16>(path)) Helpers::panic("Unsafe path in ExtSaveData::CreateFile");
|
||||
|
||||
fs::path p = IOFile::getAppData() / backingFolder;
|
||||
p += fs::path(path.utf16_string).make_preferred();
|
||||
|
||||
if (fs::exists(p))
|
||||
return Result::FS::AlreadyExists;
|
||||
if (fs::exists(p)) return Result::FS::AlreadyExists;
|
||||
|
||||
// Create a file of size "size" by creating an empty one, seeking to size - 1 and just writing a 0 there
|
||||
IOFile file(p.string().c_str(), "wb");
|
||||
|
|
@ -34,8 +32,7 @@ HorizonResult ExtSaveDataArchive::createFile(const FSPath& path, u64 size) {
|
|||
|
||||
HorizonResult ExtSaveDataArchive::deleteFile(const FSPath& path) {
|
||||
if (path.type == PathType::UTF16) {
|
||||
if (!isPathSafe<PathType::UTF16>(path))
|
||||
Helpers::panic("Unsafe path in ExtSaveData::DeleteFile");
|
||||
if (!isPathSafe<PathType::UTF16>(path)) Helpers::panic("Unsafe path in ExtSaveData::DeleteFile");
|
||||
|
||||
fs::path p = IOFile::getAppData() / backingFolder;
|
||||
p += fs::path(path.utf16_string).make_preferred();
|
||||
|
|
@ -66,11 +63,9 @@ HorizonResult ExtSaveDataArchive::deleteFile(const FSPath& path) {
|
|||
|
||||
FileDescriptor ExtSaveDataArchive::openFile(const FSPath& path, const FilePerms& perms) {
|
||||
if (path.type == PathType::UTF16) {
|
||||
if (!isPathSafe<PathType::UTF16>(path))
|
||||
Helpers::panic("Unsafe path in ExtSaveData::OpenFile");
|
||||
if (!isPathSafe<PathType::UTF16>(path)) Helpers::panic("Unsafe path in ExtSaveData::OpenFile");
|
||||
|
||||
if (perms.create())
|
||||
Helpers::panic("[ExtSaveData] Can't open file with create flag");
|
||||
if (perms.create()) Helpers::panic("[ExtSaveData] Can't open file with create flag");
|
||||
|
||||
fs::path p = IOFile::getAppData() / backingFolder;
|
||||
p += fs::path(path.utf16_string).make_preferred();
|
||||
|
|
@ -155,7 +150,7 @@ std::string ExtSaveDataArchive::getExtSaveDataPathFromBinary(const FSPath& path)
|
|||
return backingFolder + std::to_string(saveLow) + std::to_string(saveHigh);
|
||||
}
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> ExtSaveDataArchive::openArchive(const FSPath& path) {
|
||||
std::expected<ArchiveBase*, HorizonResult> ExtSaveDataArchive::openArchive(const FSPath& path) {
|
||||
if (path.type != PathType::Binary || path.binary.size() != 12) {
|
||||
Helpers::panic("ExtSaveData accessed with an invalid path in OpenArchive");
|
||||
}
|
||||
|
|
@ -165,34 +160,33 @@ Rust::Result<ArchiveBase*, HorizonResult> ExtSaveDataArchive::openArchive(const
|
|||
// fs::path formatInfopath = IOFile::getAppData() / "FormatInfo" / (getExtSaveDataPathFromBinary(path) + ".format");
|
||||
// Format info not found so the archive is not formatted
|
||||
// if (!fs::is_regular_file(formatInfopath)) {
|
||||
// return isShared ? Err(Result::FS::NotFormatted) : Err(Result::FS::NotFoundInvalid);
|
||||
// return isShared ? std::unexpected(Result::FS::NotFormatted) : std::unexpected(Result::FS::NotFoundInvalid);
|
||||
//}
|
||||
|
||||
return Ok((ArchiveBase*)this);
|
||||
return (ArchiveBase*)this;
|
||||
}
|
||||
|
||||
Rust::Result<DirectorySession, HorizonResult> ExtSaveDataArchive::openDirectory(const FSPath& path) {
|
||||
std::expected<DirectorySession, HorizonResult> ExtSaveDataArchive::openDirectory(const FSPath& path) {
|
||||
if (path.type == PathType::UTF16) {
|
||||
if (!isPathSafe<PathType::UTF16>(path))
|
||||
Helpers::panic("Unsafe path in ExtSaveData::OpenDirectory");
|
||||
if (!isPathSafe<PathType::UTF16>(path)) Helpers::panic("Unsafe path in ExtSaveData::OpenDirectory");
|
||||
|
||||
fs::path p = IOFile::getAppData() / backingFolder;
|
||||
p += fs::path(path.utf16_string).make_preferred();
|
||||
|
||||
if (fs::is_regular_file(p)) {
|
||||
printf("ExtSaveData: OpenArchive used with a file path");
|
||||
return Err(Result::FS::UnexpectedFileOrDir);
|
||||
return std::unexpected(Result::FS::UnexpectedFileOrDir);
|
||||
}
|
||||
|
||||
if (fs::is_directory(p)) {
|
||||
return Ok(DirectorySession(this, p));
|
||||
return DirectorySession(this, p);
|
||||
} else {
|
||||
return Err(Result::FS::FileNotFoundAlt);
|
||||
return std::unexpected(Result::FS::FileNotFoundAlt);
|
||||
}
|
||||
}
|
||||
|
||||
Helpers::panic("ExtSaveDataArchive::OpenDirectory: Unimplemented path type");
|
||||
return Err(Result::Success);
|
||||
return std::unexpected(Result::Success);
|
||||
}
|
||||
|
||||
std::optional<u32> ExtSaveDataArchive::readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) {
|
||||
|
|
|
|||
|
|
@ -1,9 +1,11 @@
|
|||
#include "fs/archive_ncch.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <memory>
|
||||
|
||||
#include "fs/bad_word_list.hpp"
|
||||
#include "fs/country_list.hpp"
|
||||
#include "fs/mii_data.hpp"
|
||||
#include <algorithm>
|
||||
#include <memory>
|
||||
|
||||
namespace PathType {
|
||||
enum : u32 {
|
||||
|
|
@ -14,11 +16,7 @@ namespace PathType {
|
|||
};
|
||||
|
||||
namespace MediaType {
|
||||
enum : u8 {
|
||||
NAND = 0,
|
||||
SD = 1,
|
||||
Gamecard = 2
|
||||
};
|
||||
enum : u8 { NAND = 0, SD = 1, Gamecard = 2 };
|
||||
};
|
||||
|
||||
HorizonResult NCCHArchive::createFile(const FSPath& path, u64 size) {
|
||||
|
|
@ -37,27 +35,24 @@ FileDescriptor NCCHArchive::openFile(const FSPath& path, const FilePerms& perms)
|
|||
}
|
||||
|
||||
const u32 media = *(u32*)&path.binary[0]; // 0 for NCCH, 1 for SaveData
|
||||
if (media != 0)
|
||||
Helpers::panic("NCCHArchive::OpenFile: Tried to read non-NCCH file");
|
||||
if (media != 0) Helpers::panic("NCCHArchive::OpenFile: Tried to read non-NCCH file");
|
||||
|
||||
// Third word of the binary path indicates what we're reading from.
|
||||
const u32 type = *(u32*)&path.binary[8];
|
||||
if (media == 0 && type > 2)
|
||||
Helpers::panic("NCCHArchive::OpenFile: Invalid file path type");
|
||||
if (media == 0 && type > 2) Helpers::panic("NCCHArchive::OpenFile: Invalid file path type");
|
||||
|
||||
return NoFile;
|
||||
}
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> NCCHArchive::openArchive(const FSPath& path) {
|
||||
std::expected<ArchiveBase*, HorizonResult> NCCHArchive::openArchive(const FSPath& path) {
|
||||
if (path.type != PathType::Binary || path.binary.size() != 16) {
|
||||
Helpers::panic("NCCHArchive::OpenArchive: Invalid path");
|
||||
}
|
||||
|
||||
const u32 mediaType = path.binary[8];
|
||||
if (mediaType != 0)
|
||||
Helpers::panic("NCCH archive. Tried to access a mediatype other than the NAND. Type: %d", mediaType);
|
||||
if (mediaType != 0) Helpers::panic("NCCH archive. Tried to access a mediatype other than the NAND. Type: %d", mediaType);
|
||||
|
||||
return Ok((ArchiveBase*)this);
|
||||
return (ArchiveBase*)this;
|
||||
}
|
||||
|
||||
std::optional<u32> NCCHArchive::readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) {
|
||||
|
|
@ -87,18 +82,21 @@ std::optional<u32> NCCHArchive::readFile(FileSession* file, u64 offset, u32 size
|
|||
std::vector<u8> fileData;
|
||||
|
||||
if (highProgramID == sharedDataArchive) {
|
||||
if (lowProgramID == miiData) fileData = std::vector<u8>(std::begin(MII_DATA), std::end(MII_DATA));
|
||||
else if (lowProgramID == regionManifest) fileData = std::vector<u8>(std::begin(COUNTRY_LIST_DATA), std::end(COUNTRY_LIST_DATA));
|
||||
if (lowProgramID == miiData)
|
||||
fileData = std::vector<u8>(std::begin(MII_DATA), std::end(MII_DATA));
|
||||
else if (lowProgramID == regionManifest)
|
||||
fileData = std::vector<u8>(std::begin(COUNTRY_LIST_DATA), std::end(COUNTRY_LIST_DATA));
|
||||
else if (lowProgramID == tlsRootCertificates) {
|
||||
Helpers::warn("Read from Shared Data archive 00010602");
|
||||
return 0;
|
||||
}
|
||||
else Helpers::panic("[NCCH archive] Read unimplemented NAND file. ID: %08X", lowProgramID);
|
||||
} else
|
||||
Helpers::panic("[NCCH archive] Read unimplemented NAND file. ID: %08X", lowProgramID);
|
||||
} else if (highProgramID == systemDataArchive && lowProgramID == badWordList) {
|
||||
fileData = std::vector<u8>(std::begin(BAD_WORD_LIST_DATA), std::end(BAD_WORD_LIST_DATA));
|
||||
} else {
|
||||
Helpers::panic("[NCCH archive] Read from unimplemented NCCH archive file. High program ID: %08X, low ID: %08X",
|
||||
highProgramID, lowProgramID);
|
||||
Helpers::panic(
|
||||
"[NCCH archive] Read from unimplemented NCCH archive file. High program ID: %08X, low ID: %08X", highProgramID, lowProgramID
|
||||
);
|
||||
}
|
||||
|
||||
if (offset >= fileData.size()) {
|
||||
|
|
@ -117,8 +115,7 @@ std::optional<u32> NCCHArchive::readFile(FileSession* file, u64 offset, u32 size
|
|||
}
|
||||
|
||||
// Code below is for mediaType == 2 (gamecard). Currently unused
|
||||
if (partition != 0)
|
||||
Helpers::panic("[NCCH] Tried to read from non-zero partition");
|
||||
if (partition != 0) Helpers::panic("[NCCH] Tried to read from non-zero partition");
|
||||
|
||||
if (type == PathType::RomFS && !hasRomFS()) {
|
||||
Helpers::panic("Tried to read file from non-existent RomFS");
|
||||
|
|
@ -150,8 +147,7 @@ std::optional<u32> NCCHArchive::readFile(FileSession* file, u64 offset, u32 size
|
|||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
Helpers::panic("Unimplemented file path type for NCCH archive");
|
||||
default: Helpers::panic("Unimplemented file path type for NCCH archive");
|
||||
}
|
||||
|
||||
std::unique_ptr<u8[]> data(new u8[size]);
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
#include "fs/archive_save_data.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <memory>
|
||||
|
||||
|
|
@ -6,8 +7,7 @@ namespace fs = std::filesystem;
|
|||
|
||||
HorizonResult SaveDataArchive::createFile(const FSPath& path, u64 size) {
|
||||
if (path.type == PathType::UTF16) {
|
||||
if (!isPathSafe<PathType::UTF16>(path))
|
||||
Helpers::panic("Unsafe path in SaveData::CreateFile");
|
||||
if (!isPathSafe<PathType::UTF16>(path)) Helpers::panic("Unsafe path in SaveData::CreateFile");
|
||||
|
||||
fs::path p = IOFile::getAppData() / "SaveData";
|
||||
p += fs::path(path.utf16_string).make_preferred();
|
||||
|
|
@ -131,7 +131,7 @@ FileDescriptor SaveDataArchive::openFile(const FSPath& path, const FilePerms& pe
|
|||
return FileError;
|
||||
}
|
||||
|
||||
Rust::Result<DirectorySession, HorizonResult> SaveDataArchive::openDirectory(const FSPath& path) {
|
||||
std::expected<DirectorySession, HorizonResult> SaveDataArchive::openDirectory(const FSPath& path) {
|
||||
if (path.type == PathType::UTF16) {
|
||||
if (!isPathSafe<PathType::UTF16>(path)) {
|
||||
Helpers::panic("Unsafe path in SaveData::OpenDirectory");
|
||||
|
|
@ -142,27 +142,27 @@ Rust::Result<DirectorySession, HorizonResult> SaveDataArchive::openDirectory(con
|
|||
|
||||
if (fs::is_regular_file(p)) {
|
||||
printf("SaveData: OpenDirectory used with a file path");
|
||||
return Err(Result::FS::UnexpectedFileOrDir);
|
||||
return std::unexpected(Result::FS::UnexpectedFileOrDir);
|
||||
}
|
||||
|
||||
if (fs::is_directory(p)) {
|
||||
return Ok(DirectorySession(this, p));
|
||||
return DirectorySession(this, p);
|
||||
} else {
|
||||
return Err(Result::FS::FileNotFoundAlt);
|
||||
return std::unexpected(Result::FS::FileNotFoundAlt);
|
||||
}
|
||||
}
|
||||
|
||||
Helpers::panic("SaveDataArchive::OpenDirectory: Unimplemented path type");
|
||||
return Err(Result::Success);
|
||||
return std::unexpected(Result::Success);
|
||||
}
|
||||
|
||||
Rust::Result<ArchiveBase::FormatInfo, HorizonResult> SaveDataArchive::getFormatInfo(const FSPath& path) {
|
||||
std::expected<ArchiveBase::FormatInfo, HorizonResult> SaveDataArchive::getFormatInfo(const FSPath& path) {
|
||||
const fs::path formatInfoPath = getFormatInfoPath();
|
||||
IOFile file(formatInfoPath, "rb");
|
||||
|
||||
// If the file failed to open somehow, we return that the archive is not formatted
|
||||
if (!file.isOpen()) {
|
||||
return Err(Result::FS::NotFormatted);
|
||||
return std::unexpected(Result::FS::NotFormatted);
|
||||
}
|
||||
|
||||
FormatInfo ret;
|
||||
|
|
@ -171,10 +171,10 @@ Rust::Result<ArchiveBase::FormatInfo, HorizonResult> SaveDataArchive::getFormatI
|
|||
|
||||
if (!success || bytesRead != sizeof(FormatInfo)) {
|
||||
Helpers::warn("SaveData::GetFormatInfo: Format file exists but was not properly read into the FormatInfo struct");
|
||||
return Err(Result::FS::NotFormatted);
|
||||
return std::unexpected(Result::FS::NotFormatted);
|
||||
}
|
||||
|
||||
return Ok(ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void SaveDataArchive::format(const FSPath& path, const ArchiveBase::FormatInfo& info) {
|
||||
|
|
@ -192,19 +192,19 @@ void SaveDataArchive::format(const FSPath& path, const ArchiveBase::FormatInfo&
|
|||
file.close();
|
||||
}
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> SaveDataArchive::openArchive(const FSPath& path) {
|
||||
std::expected<ArchiveBase*, HorizonResult> SaveDataArchive::openArchive(const FSPath& path) {
|
||||
if (path.type != PathType::Empty) {
|
||||
Helpers::panic("Unimplemented path type for SaveData archive: %d\n", path.type);
|
||||
return Err(Result::FS::NotFoundInvalid);
|
||||
return std::unexpected(Result::FS::NotFoundInvalid);
|
||||
}
|
||||
|
||||
const fs::path formatInfoPath = getFormatInfoPath();
|
||||
// Format info not found so the archive is not formatted
|
||||
if (!fs::is_regular_file(formatInfoPath)) {
|
||||
return Err(Result::FS::NotFormatted);
|
||||
return std::unexpected(Result::FS::NotFormatted);
|
||||
}
|
||||
|
||||
return Ok((ArchiveBase*)this);
|
||||
return (ArchiveBase*)this;
|
||||
}
|
||||
|
||||
std::optional<u32> SaveDataArchive::readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) {
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
#include "fs/archive_sdmc.hpp"
|
||||
|
||||
#include <memory>
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
|
|
@ -137,10 +138,10 @@ HorizonResult SDMCArchive::createDirectory(const FSPath& path) {
|
|||
return success ? Result::Success : Result::FS::UnexpectedFileOrDir;
|
||||
}
|
||||
|
||||
Rust::Result<DirectorySession, HorizonResult> SDMCArchive::openDirectory(const FSPath& path) {
|
||||
std::expected<DirectorySession, HorizonResult> SDMCArchive::openDirectory(const FSPath& path) {
|
||||
if (isWriteOnly) {
|
||||
Helpers::warn("SDMC: OpenDirectory is not allowed in SDMC Write-Only archive");
|
||||
return Err(Result::FS::UnexpectedFileOrDir);
|
||||
return std::unexpected(Result::FS::UnexpectedFileOrDir);
|
||||
}
|
||||
|
||||
if (path.type == PathType::UTF16) {
|
||||
|
|
@ -153,27 +154,27 @@ Rust::Result<DirectorySession, HorizonResult> SDMCArchive::openDirectory(const F
|
|||
|
||||
if (fs::is_regular_file(p)) {
|
||||
printf("SDMC: OpenDirectory used with a file path");
|
||||
return Err(Result::FS::UnexpectedFileOrDir);
|
||||
return std::unexpected(Result::FS::UnexpectedFileOrDir);
|
||||
}
|
||||
|
||||
if (fs::is_directory(p)) {
|
||||
return Ok(DirectorySession(this, p));
|
||||
return DirectorySession(this, p);
|
||||
} else {
|
||||
return Err(Result::FS::FileNotFoundAlt);
|
||||
return std::unexpected(Result::FS::FileNotFoundAlt);
|
||||
}
|
||||
}
|
||||
|
||||
Helpers::panic("SDMCArchive::OpenDirectory: Unimplemented path type");
|
||||
return Err(Result::Success);
|
||||
return std::unexpected(Result::Success);
|
||||
}
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> SDMCArchive::openArchive(const FSPath& path) {
|
||||
std::expected<ArchiveBase*, HorizonResult> SDMCArchive::openArchive(const FSPath& path) {
|
||||
// TODO: Fail here if the SD is disabled in the connfig.
|
||||
if (path.type != PathType::Empty) {
|
||||
Helpers::panic("Unimplemented path type for SDMC::OpenArchive");
|
||||
}
|
||||
|
||||
return Ok((ArchiveBase*)this);
|
||||
return (ArchiveBase*)this;
|
||||
}
|
||||
|
||||
std::optional<u32> SDMCArchive::readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) {
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
#include "fs/archive_self_ncch.hpp"
|
||||
|
||||
#include <memory>
|
||||
|
||||
// The part of the NCCH archive we're trying to access. Depends on the first 4 bytes of the binary file path
|
||||
|
|
@ -41,13 +42,13 @@ FileDescriptor SelfNCCHArchive::openFile(const FSPath& path, const FilePerms& pe
|
|||
return NoFile; // No file descriptor needed for RomFS
|
||||
}
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> SelfNCCHArchive::openArchive(const FSPath& path) {
|
||||
std::expected<ArchiveBase*, HorizonResult> SelfNCCHArchive::openArchive(const FSPath& path) {
|
||||
if (path.type != PathType::Empty) {
|
||||
Helpers::panic("Invalid path type for SelfNCCH archive: %d\n", path.type);
|
||||
return Err(Result::FS::NotFoundInvalid);
|
||||
return std::unexpected(Result::FS::NotFoundInvalid);
|
||||
}
|
||||
|
||||
return Ok((ArchiveBase*)this);
|
||||
return (ArchiveBase*)this;
|
||||
}
|
||||
|
||||
std::optional<u32> SelfNCCHArchive::readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) {
|
||||
|
|
|
|||
|
|
@ -1,14 +1,15 @@
|
|||
#include <algorithm>
|
||||
#include "fs/archive_system_save_data.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> SystemSaveDataArchive::openArchive(const FSPath& path) {
|
||||
std::expected<ArchiveBase*, HorizonResult> SystemSaveDataArchive::openArchive(const FSPath& path) {
|
||||
if (path.type != PathType::Binary) {
|
||||
Helpers::panic("Unimplemented path type for SystemSaveData::OpenArchive");
|
||||
}
|
||||
|
||||
return Ok((ArchiveBase*)this);
|
||||
return (ArchiveBase*)this;
|
||||
}
|
||||
|
||||
FileDescriptor SystemSaveDataArchive::openFile(const FSPath& path, const FilePerms& perms) {
|
||||
|
|
@ -108,7 +109,6 @@ HorizonResult SystemSaveDataArchive::createDirectory(const FSPath& path) {
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
HorizonResult SystemSaveDataArchive::deleteFile(const FSPath& path) {
|
||||
if (path.type == PathType::UTF16) {
|
||||
if (!isPathSafe<PathType::UTF16>(path)) {
|
||||
|
|
@ -142,11 +142,11 @@ HorizonResult SystemSaveDataArchive::deleteFile(const FSPath& path) {
|
|||
return Result::Success;
|
||||
}
|
||||
|
||||
Rust::Result<DirectorySession, HorizonResult> SystemSaveDataArchive::openDirectory(const FSPath& path) {
|
||||
std::expected<DirectorySession, HorizonResult> SystemSaveDataArchive::openDirectory(const FSPath& path) {
|
||||
if (path.type == PathType::UTF16) {
|
||||
if (!isPathSafe<PathType::UTF16>(path)) {
|
||||
Helpers::warn("Unsafe path in SystemSaveData::OpenDirectory");
|
||||
return Err(Result::FS::FileNotFoundAlt);
|
||||
return std::unexpected(Result::FS::FileNotFoundAlt);
|
||||
}
|
||||
|
||||
fs::path p = IOFile::getAppData() / ".." / "SharedFiles" / "SystemSaveData";
|
||||
|
|
@ -154,16 +154,16 @@ Rust::Result<DirectorySession, HorizonResult> SystemSaveDataArchive::openDirecto
|
|||
|
||||
if (fs::is_regular_file(p)) {
|
||||
printf("SystemSaveData: OpenDirectory used with a file path");
|
||||
return Err(Result::FS::UnexpectedFileOrDir);
|
||||
return std::unexpected(Result::FS::UnexpectedFileOrDir);
|
||||
}
|
||||
|
||||
if (fs::is_directory(p)) {
|
||||
return Ok(DirectorySession(this, p));
|
||||
return DirectorySession(this, p);
|
||||
} else {
|
||||
return Err(Result::FS::FileNotFoundAlt);
|
||||
return std::unexpected(Result::FS::FileNotFoundAlt);
|
||||
}
|
||||
}
|
||||
|
||||
Helpers::panic("SystemSaveData::OpenDirectory: Unimplemented path type");
|
||||
return Err(Result::Success);
|
||||
return std::unexpected(Result::Success);
|
||||
}
|
||||
|
|
@ -1,8 +1,8 @@
|
|||
#include "fs/archive_user_save_data.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <memory>
|
||||
|
||||
#include "fs/archive_user_save_data.hpp"
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
HorizonResult UserSaveDataArchive::createFile(const FSPath& path, u64 size) {
|
||||
|
|
@ -118,7 +118,7 @@ FileDescriptor UserSaveDataArchive::openFile(const FSPath& path, const FilePerms
|
|||
return FileError;
|
||||
}
|
||||
|
||||
Rust::Result<DirectorySession, HorizonResult> UserSaveDataArchive::openDirectory(const FSPath& path) {
|
||||
std::expected<DirectorySession, HorizonResult> UserSaveDataArchive::openDirectory(const FSPath& path) {
|
||||
if (path.type == PathType::UTF16) {
|
||||
if (!isPathSafe<PathType::UTF16>(path)) Helpers::panic("Unsafe path in UserSaveData::OpenDirectory");
|
||||
|
||||
|
|
@ -127,27 +127,27 @@ Rust::Result<DirectorySession, HorizonResult> UserSaveDataArchive::openDirectory
|
|||
|
||||
if (fs::is_regular_file(p)) {
|
||||
printf("SaveData: OpenDirectory used with a file path");
|
||||
return Err(Result::FS::UnexpectedFileOrDir);
|
||||
return std::unexpected(Result::FS::UnexpectedFileOrDir);
|
||||
}
|
||||
|
||||
if (fs::is_directory(p)) {
|
||||
return Ok(DirectorySession(this, p));
|
||||
return DirectorySession(this, p);
|
||||
} else {
|
||||
return Err(Result::FS::FileNotFoundAlt);
|
||||
return std::unexpected(Result::FS::FileNotFoundAlt);
|
||||
}
|
||||
}
|
||||
|
||||
Helpers::panic("UserSaveDataArchive::OpenDirectory: Unimplemented path type");
|
||||
return Err(Result::Success);
|
||||
return std::unexpected(Result::Success);
|
||||
}
|
||||
|
||||
Rust::Result<ArchiveBase::FormatInfo, HorizonResult> UserSaveDataArchive::getFormatInfo(const FSPath& path) {
|
||||
std::expected<ArchiveBase::FormatInfo, HorizonResult> UserSaveDataArchive::getFormatInfo(const FSPath& path) {
|
||||
const fs::path formatInfoPath = getFormatInfoPath();
|
||||
IOFile file(formatInfoPath, "rb");
|
||||
|
||||
// If the file failed to open somehow, we return that the archive is not formatted
|
||||
if (!file.isOpen()) {
|
||||
return Err(Result::FS::NotFormatted);
|
||||
return std::unexpected(Result::FS::NotFormatted);
|
||||
}
|
||||
|
||||
FormatInfo ret;
|
||||
|
|
@ -156,10 +156,10 @@ Rust::Result<ArchiveBase::FormatInfo, HorizonResult> UserSaveDataArchive::getFor
|
|||
|
||||
if (!success || bytesRead != sizeof(FormatInfo)) {
|
||||
Helpers::warn("UserSaveData::GetFormatInfo: Format file exists but was not properly read into the FormatInfo struct");
|
||||
return Err(Result::FS::NotFormatted);
|
||||
return std::unexpected(Result::FS::NotFormatted);
|
||||
}
|
||||
|
||||
return Ok(ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void UserSaveDataArchive::format(const FSPath& path, const ArchiveBase::FormatInfo& info) {
|
||||
|
|
@ -177,19 +177,19 @@ void UserSaveDataArchive::format(const FSPath& path, const ArchiveBase::FormatIn
|
|||
file.close();
|
||||
}
|
||||
|
||||
Rust::Result<ArchiveBase*, HorizonResult> UserSaveDataArchive::openArchive(const FSPath& path) {
|
||||
std::expected<ArchiveBase*, HorizonResult> UserSaveDataArchive::openArchive(const FSPath& path) {
|
||||
if (path.type != PathType::Binary) {
|
||||
Helpers::panic("Unimplemented path type for UserSaveData archive: %d\n", path.type);
|
||||
return Err(Result::FS::NotFoundInvalid);
|
||||
return std::unexpected(Result::FS::NotFoundInvalid);
|
||||
}
|
||||
|
||||
const fs::path formatInfoPath = getFormatInfoPath();
|
||||
// Format info not found so the archive is not formatted
|
||||
if (!fs::is_regular_file(formatInfoPath)) {
|
||||
return Err(Result::FS::NotFormatted);
|
||||
return std::unexpected(Result::FS::NotFormatted);
|
||||
}
|
||||
|
||||
return Ok((ArchiveBase*)this);
|
||||
return (ArchiveBase*)this;
|
||||
}
|
||||
|
||||
std::optional<u32> UserSaveDataArchive::readFile(FileSession* file, u64 offset, u32 size, u32 dataPointer) {
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
#include "services/fs.hpp"
|
||||
#include "kernel/kernel.hpp"
|
||||
|
||||
#include "io_file.hpp"
|
||||
#include "ipc.hpp"
|
||||
#include "kernel/kernel.hpp"
|
||||
#include "result/result.hpp"
|
||||
|
||||
#ifdef CreateFile // windows.h defines CreateFile & DeleteFile because of course it does.
|
||||
|
|
@ -47,9 +48,7 @@ namespace FSCommands {
|
|||
};
|
||||
}
|
||||
|
||||
void FSService::reset() {
|
||||
priority = 0;
|
||||
}
|
||||
void FSService::reset() { priority = 0; }
|
||||
|
||||
// Creates directories for NAND, ExtSaveData, etc if they don't already exist. Should be executed after loading a new ROM.
|
||||
void FSService::initializeFilesystem() {
|
||||
|
|
@ -61,7 +60,6 @@ void FSService::initializeFilesystem() {
|
|||
const auto systemSaveDataPath = IOFile::getAppData() / ".." / "SharedFiles" / "SystemSaveData";
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
|
||||
if (!fs::is_directory(nandSharedpath)) {
|
||||
fs::create_directories(nandSharedpath);
|
||||
}
|
||||
|
|
@ -89,19 +87,15 @@ ArchiveBase* FSService::getArchiveFromID(u32 id, const FSPath& archivePath) {
|
|||
case ArchiveID::SaveData: return &saveData;
|
||||
case ArchiveID::UserSaveData2: return &userSaveData2;
|
||||
|
||||
case ArchiveID::ExtSaveData:
|
||||
return &extSaveData_sdmc;
|
||||
case ArchiveID::ExtSaveData: return &extSaveData_sdmc;
|
||||
|
||||
case ArchiveID::SharedExtSaveData:
|
||||
return &sharedExtSaveData_nand;
|
||||
case ArchiveID::SharedExtSaveData: return &sharedExtSaveData_nand;
|
||||
|
||||
case ArchiveID::SystemSaveData: return &systemSaveData;
|
||||
case ArchiveID::SDMC: return &sdmc;
|
||||
case ArchiveID::SDMCWriteOnly: return &sdmcWriteOnly;
|
||||
case ArchiveID::SavedataAndNcch: return &ncch; // This can only access NCCH outside of FSPXI
|
||||
default:
|
||||
Helpers::panic("Unknown archive. ID: %d\n", id);
|
||||
return nullptr;
|
||||
default: Helpers::panic("Unknown archive. ID: %d\n", id); return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -119,37 +113,36 @@ std::optional<Handle> FSService::openFileHandle(ArchiveBase* archive, const FSPa
|
|||
}
|
||||
}
|
||||
|
||||
Rust::Result<Handle, Result::HorizonResult> FSService::openDirectoryHandle(ArchiveBase* archive, const FSPath& path) {
|
||||
Rust::Result<DirectorySession, Result::HorizonResult> opened = archive->openDirectory(path);
|
||||
if (opened.isOk()) { // If opened doesn't have a value, we failed to open the directory
|
||||
std::expected<Handle, Result::HorizonResult> FSService::openDirectoryHandle(ArchiveBase* archive, const FSPath& path) {
|
||||
std::expected<DirectorySession, Result::HorizonResult> opened = archive->openDirectory(path);
|
||||
if (opened) { // If opened doesn't have a value, we failed to open the directory
|
||||
auto handle = kernel.makeObject(KernelObjectType::Directory);
|
||||
auto& object = kernel.getObjects()[handle];
|
||||
object.data = new DirectorySession(opened.unwrap());
|
||||
object.data = new DirectorySession(opened.value());
|
||||
|
||||
return Ok(handle);
|
||||
return handle;
|
||||
} else {
|
||||
return Err(opened.unwrapErr());
|
||||
return std::unexpected(opened.error());
|
||||
}
|
||||
}
|
||||
|
||||
Rust::Result<Handle, Result::HorizonResult> FSService::openArchiveHandle(u32 archiveID, const FSPath& path) {
|
||||
std::expected<Handle, Result::HorizonResult> FSService::openArchiveHandle(u32 archiveID, const FSPath& path) {
|
||||
ArchiveBase* archive = getArchiveFromID(archiveID, path);
|
||||
|
||||
if (archive == nullptr) [[unlikely]] {
|
||||
Helpers::panic("OpenArchive: Tried to open unknown archive %d.", archiveID);
|
||||
return Err(Result::FS::NotFormatted);
|
||||
return std::unexpected(Result::FS::NotFormatted);
|
||||
}
|
||||
|
||||
Rust::Result<ArchiveBase*, Result::HorizonResult> res = archive->openArchive(path);
|
||||
if (res.isOk()) {
|
||||
std::expected<ArchiveBase*, Result::HorizonResult> res = archive->openArchive(path);
|
||||
if (res.has_value()) {
|
||||
auto handle = kernel.makeObject(KernelObjectType::Archive);
|
||||
auto& archiveObject = kernel.getObjects()[handle];
|
||||
archiveObject.data = new ArchiveSession(res.unwrap(), path);
|
||||
archiveObject.data = new ArchiveSession(res.value(), path);
|
||||
|
||||
return Ok(handle);
|
||||
}
|
||||
else {
|
||||
return Err(res.unwrapErr());
|
||||
return handle;
|
||||
} else {
|
||||
return std::unexpected(res.error());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -157,8 +150,7 @@ FSPath FSService::readPath(u32 type, u32 pointer, u32 size) {
|
|||
std::vector<u8> data;
|
||||
data.resize(size);
|
||||
|
||||
for (u32 i = 0; i < size; i++)
|
||||
data[i] = mem.read8(pointer + i);
|
||||
for (u32 i = 0; i < size; i++) data[i] = mem.read8(pointer + i);
|
||||
|
||||
return FSPath(type, data);
|
||||
}
|
||||
|
|
@ -241,14 +233,14 @@ void FSService::openArchive(u32 messagePointer) {
|
|||
auto archivePath = readPath(archivePathType, archivePathPointer, archivePathSize);
|
||||
log("FS::OpenArchive(archive ID = %d, archive path type = %d)\n", archiveID, archivePathType);
|
||||
|
||||
Rust::Result<Handle, Result::HorizonResult> res = openArchiveHandle(archiveID, archivePath);
|
||||
std::expected<Handle, Result::HorizonResult> res = openArchiveHandle(archiveID, archivePath);
|
||||
mem.write32(messagePointer, IPC::responseHeader(0x80C, 3, 0));
|
||||
if (res.isOk()) {
|
||||
if (res.has_value()) {
|
||||
mem.write32(messagePointer + 4, Result::Success);
|
||||
mem.write64(messagePointer + 8, res.unwrap());
|
||||
mem.write64(messagePointer + 8, res.value());
|
||||
} else {
|
||||
log("FS::OpenArchive: Failed to open archive with id = %d. Error %08X\n", archiveID, (u32)res.unwrapErr());
|
||||
mem.write32(messagePointer + 4, res.unwrapErr());
|
||||
log("FS::OpenArchive: Failed to open archive with id = %d. Error %08X\n", archiveID, (u32)res.error());
|
||||
mem.write32(messagePointer + 4, res.error());
|
||||
mem.write64(messagePointer + 8, 0);
|
||||
}
|
||||
}
|
||||
|
|
@ -330,12 +322,12 @@ void FSService::openDirectory(u32 messagePointer) {
|
|||
auto dir = openDirectoryHandle(archive, dirPath);
|
||||
|
||||
mem.write32(messagePointer, IPC::responseHeader(0x80B, 1, 2));
|
||||
if (dir.isOk()) {
|
||||
if (dir.has_value()) {
|
||||
mem.write32(messagePointer + 4, Result::Success);
|
||||
mem.write32(messagePointer + 12, dir.unwrap());
|
||||
mem.write32(messagePointer + 12, dir.value());
|
||||
} else {
|
||||
printf("FS::OpenDirectory failed\n");
|
||||
mem.write32(messagePointer + 4, static_cast<u32>(dir.unwrapErr()));
|
||||
mem.write32(messagePointer + 4, static_cast<u32>(dir.error()));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -360,11 +352,11 @@ void FSService::openFileDirectly(u32 messagePointer) {
|
|||
auto filePath = readPath(filePathType, filePathPointer, filePathSize);
|
||||
const FilePerms perms(openFlags);
|
||||
|
||||
Rust::Result<ArchiveBase*, Result::HorizonResult> res = archive->openArchive(archivePath);
|
||||
if (res.isErr()) [[unlikely]] {
|
||||
std::expected<ArchiveBase*, Result::HorizonResult> res = archive->openArchive(archivePath);
|
||||
if (!res.has_value()) [[unlikely]] {
|
||||
Helpers::panic("OpenFileDirectly: Failed to open archive with given path");
|
||||
}
|
||||
archive = res.unwrap();
|
||||
archive = res.value();
|
||||
|
||||
std::optional<Handle> handle = openFileHandle(archive, filePath, archivePath, perms);
|
||||
mem.write32(messagePointer, IPC::responseHeader(0x803, 1, 2));
|
||||
|
|
@ -451,18 +443,18 @@ void FSService::getFormatInfo(u32 messagePointer) {
|
|||
}
|
||||
|
||||
mem.write32(messagePointer, IPC::responseHeader(0x845, 5, 0));
|
||||
Rust::Result<ArchiveBase::FormatInfo, Result::HorizonResult> res = archive->getFormatInfo(path);
|
||||
std::expected<ArchiveBase::FormatInfo, Result::HorizonResult> res = archive->getFormatInfo(path);
|
||||
|
||||
// If the FormatInfo was returned, write them to the output buffer. Otherwise, write an error code.
|
||||
if (res.isOk()) {
|
||||
ArchiveBase::FormatInfo info = res.unwrap();
|
||||
if (res.has_value()) {
|
||||
ArchiveBase::FormatInfo info = res.value();
|
||||
mem.write32(messagePointer + 4, Result::Success);
|
||||
mem.write32(messagePointer + 8, info.size);
|
||||
mem.write32(messagePointer + 12, info.numOfDirectories);
|
||||
mem.write32(messagePointer + 16, info.numOfFiles);
|
||||
mem.write8(messagePointer + 20, info.duplicateData ? 1 : 0);
|
||||
} else {
|
||||
mem.write32(messagePointer + 4, static_cast<u32>(res.unwrapErr()));
|
||||
mem.write32(messagePointer + 4, static_cast<u32>(res.error()));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -470,8 +462,7 @@ void FSService::formatSaveData(u32 messagePointer) {
|
|||
log("FS::FormatSaveData\n");
|
||||
|
||||
const u32 archiveID = mem.read32(messagePointer + 4);
|
||||
if (archiveID != ArchiveID::SaveData)
|
||||
Helpers::panic("FS::FormatSaveData: Archive is not SaveData");
|
||||
if (archiveID != ArchiveID::SaveData) Helpers::panic("FS::FormatSaveData: Archive is not SaveData");
|
||||
|
||||
// Read path and path info
|
||||
const u32 pathType = mem.read32(messagePointer + 8);
|
||||
|
|
@ -481,8 +472,7 @@ void FSService::formatSaveData(u32 messagePointer) {
|
|||
// Size of a block. Seems to always be 0x200
|
||||
const u32 blockSize = mem.read32(messagePointer + 16);
|
||||
|
||||
if (blockSize != 0x200 && blockSize != 0x1000)
|
||||
Helpers::panic("FS::FormatSaveData: Invalid SaveData block size");
|
||||
if (blockSize != 0x200 && blockSize != 0x1000) Helpers::panic("FS::FormatSaveData: Invalid SaveData block size");
|
||||
|
||||
const u32 directoryNum = mem.read32(messagePointer + 20); // Max number of directories
|
||||
const u32 fileNum = mem.read32(messagePointer + 24); // Max number of files
|
||||
|
|
@ -490,12 +480,7 @@ void FSService::formatSaveData(u32 messagePointer) {
|
|||
const u32 fileBucketNum = mem.read32(messagePointer + 32); // Same here
|
||||
const bool duplicateData = mem.read8(messagePointer + 36) != 0;
|
||||
|
||||
ArchiveBase::FormatInfo info {
|
||||
.size = blockSize * 0x200,
|
||||
.numOfDirectories = directoryNum,
|
||||
.numOfFiles = fileNum,
|
||||
.duplicateData = duplicateData
|
||||
};
|
||||
ArchiveBase::FormatInfo info{.size = blockSize * 0x200, .numOfDirectories = directoryNum, .numOfFiles = fileNum, .duplicateData = duplicateData};
|
||||
|
||||
saveData.format(path, info);
|
||||
|
||||
|
|
@ -512,8 +497,8 @@ void FSService::deleteExtSaveData(u32 messagePointer) {
|
|||
log("FS::DeleteExtSaveData (media type = %d, saveID = %llx) (stubbed)\n", mediaType, saveID);
|
||||
|
||||
mem.write32(messagePointer, IPC::responseHeader(0x0852, 1, 0));
|
||||
// TODO: We can't properly implement this yet until we properly support title/save IDs. We will stub this and insert a warning for now. Required for Planet Robobot
|
||||
// When we properly implement it, it will just be a recursive directory deletion
|
||||
// TODO: We can't properly implement this yet until we properly support title/save IDs. We will stub this and insert a warning for now. Required
|
||||
// for Planet Robobot When we properly implement it, it will just be a recursive directory deletion
|
||||
mem.write32(messagePointer + 4, Result::Success);
|
||||
}
|
||||
|
||||
|
|
@ -521,7 +506,8 @@ void FSService::createExtSaveData(u32 messagePointer) {
|
|||
Helpers::warn("Stubbed call to FS::CreateExtSaveData!");
|
||||
// First 4 words of parameters are the ExtSaveData info
|
||||
// https://www.3dbrew.org/wiki/Filesystem_services#ExtSaveDataInfo
|
||||
// This creates the ExtSaveData with the specified saveid in the specified media type. It stores the SMDH as "icon" in the root of the created directory.
|
||||
// This creates the ExtSaveData with the specified saveid in the specified media type. It stores the SMDH as "icon" in the root of the created
|
||||
// directory.
|
||||
const u8 mediaType = mem.read8(messagePointer + 4);
|
||||
const u64 saveID = mem.read64(messagePointer + 8);
|
||||
const u32 numOfDirectories = mem.read32(messagePointer + 20);
|
||||
|
|
@ -547,12 +533,7 @@ void FSService::formatThisUserSaveData(u32 messagePointer) {
|
|||
const u32 fileBucketNum = mem.read32(messagePointer + 20); // Same here
|
||||
const bool duplicateData = mem.read8(messagePointer + 24) != 0;
|
||||
|
||||
ArchiveBase::FormatInfo info {
|
||||
.size = blockSize * 0x200,
|
||||
.numOfDirectories = directoryNum,
|
||||
.numOfFiles = fileNum,
|
||||
.duplicateData = duplicateData
|
||||
};
|
||||
ArchiveBase::FormatInfo info{.size = blockSize * 0x200, .numOfDirectories = directoryNum, .numOfFiles = fileNum, .duplicateData = duplicateData};
|
||||
FSPath emptyPath;
|
||||
|
||||
mem.write32(messagePointer, IPC::responseHeader(0x080F, 1, 0));
|
||||
|
|
@ -587,9 +568,7 @@ void FSService::controlArchive(u32 messagePointer) {
|
|||
mem.write32(messagePointer + 4, Result::Success);
|
||||
break;
|
||||
|
||||
default:
|
||||
Helpers::panic("Unimplemented action for ControlArchive (action = %X)\n", action);
|
||||
break;
|
||||
default: Helpers::panic("Unimplemented action for ControlArchive (action = %X)\n", action); break;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
201
third_party/result/LICENSE
vendored
201
third_party/result/LICENSE
vendored
|
|
@ -1,201 +0,0 @@
|
|||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "{}"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright {2016} {Mathieu Stefani}
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
132
third_party/result/README.md
vendored
132
third_party/result/README.md
vendored
|
|
@ -1,132 +0,0 @@
|
|||
# Result
|
||||
This is an adaption of [https://github.com/oktal/result](https://github.com/oktal/result). Make sure to support the original library!
|
||||
|
||||
## Overview
|
||||
|
||||
`Result<T, E>` is a template type that can be used to return and propage errors. It can be used to replace
|
||||
exceptions in context where they are not allowed or too slow to be used. `Result<T, E>` is an algebraic data
|
||||
type of `Ok(T)` that represents success and `Err(E)` representing an error.
|
||||
|
||||
Design of this class has been mainly inspired by Rust's [std::result](https://doc.rust-lang.org/std/result/)
|
||||
|
||||
```
|
||||
|
||||
struct Request {
|
||||
};
|
||||
|
||||
struct Error {
|
||||
|
||||
enum class Kind {
|
||||
Timeout,
|
||||
Invalid,
|
||||
TooLong
|
||||
}
|
||||
|
||||
Error(Kind kind, std::string text);
|
||||
|
||||
Kind kind;
|
||||
std::string text;
|
||||
};
|
||||
|
||||
Result<Request, Error> parseRequest(const std::string& payload) {
|
||||
if (payload.size() > 512) return Err(Error(Kind::TooLong, "Request exceeded maximum allowed size (512 bytes)"));
|
||||
|
||||
Request request;
|
||||
return Ok(request);
|
||||
}
|
||||
|
||||
std::string payload = receivePayload();
|
||||
auto request = parseRequest(payload).expect("Failed to parse request");
|
||||
```
|
||||
|
||||
To return a successfull `Result`, use the `Ok()` function. To return an error one, use the `Err()` function.
|
||||
|
||||
## Extract and unwrap
|
||||
|
||||
To extract the value from a `Result<T, E>` type, you can use the `expect()` function that will yield the value
|
||||
of an `Ok(T)` or terminate the program with an error message passed as a parameter.
|
||||
|
||||
```
|
||||
Result<uint32_t, uint32_t> r1 = Ok(3u);
|
||||
|
||||
auto val = r1.expect("Failed to retrieve the value");
|
||||
assert(val == 3);
|
||||
```
|
||||
|
||||
`unwrap()` can also be used to extract the value of a `Result`, yielding the value of an `Ok(T)` value or terminating
|
||||
the program otherwise:
|
||||
|
||||
```
|
||||
Result<uint32_t, uint32_t> r1 = Ok(3u);
|
||||
|
||||
auto val = r1.unwrap();
|
||||
assert(val == 3);
|
||||
```
|
||||
|
||||
Instead a terminating the program, `unwrapOr` can be used to return a default value for an `Err(E)` Result:
|
||||
|
||||
```
|
||||
Result<uint32_t, uint32_t> r1 = Err(9u);
|
||||
|
||||
auto val = r1.unwrapOr(0);
|
||||
assert(val == 0);
|
||||
```
|
||||
|
||||
## Map and bind
|
||||
|
||||
To transform (or map) a `Result<T, E>` to a `Result<U, E>`, `Result` provides a `map` member function.
|
||||
`map` will apply a function to a contained `Ok(T)` value and will return the result of the transformation,
|
||||
and will leave an `Err(E)` untouched:
|
||||
|
||||
```
|
||||
std::string stringify(int val) { return std::to_string(val); }
|
||||
|
||||
Result<uint32_t, uint32_t> r1 = Ok(2u);
|
||||
auto r2 = r1.map(stringify); // Maps a Result<uint32_t, uint32_t> to Result<std::string, uint32_t>
|
||||
|
||||
assert(r2.unwrap(), "2");
|
||||
```
|
||||
|
||||
Note that `map` should return a simple value and not a `Result<U, E>`. A function returning nothing (`void`)
|
||||
applied to a `Result<T, E>` will yield a `Result<void, E>`.
|
||||
|
||||
To map a function to a contained `Err(E)` value, use the `mapError` function.
|
||||
|
||||
To *bind* a `Result<T, E>` to a `Result<U, E>`, you can use the `andThen` member function:
|
||||
|
||||
```
|
||||
Result<uint32_t, uint32_t> square(uint32_t val) { return Ok(val * val); }
|
||||
|
||||
Result<uint32_t, uint32_t> r1 = Ok(3u);
|
||||
auto r2 = r1.andThen(square);
|
||||
|
||||
assert(r2.unwrap(), 9);
|
||||
```
|
||||
|
||||
Use `orElse` to apply a function to a contained `Err(E)` value:
|
||||
|
||||
```
|
||||
Result<uint32_t, uint32_t> identity(uint32_t val) { return Ok(val); }
|
||||
|
||||
Result<uint32_t, uint32_t> r1 = Err(3u);
|
||||
assert(r1.andThen(identity).orElse(square).unwrap(), 9);
|
||||
```
|
||||
|
||||
## The TRY macro
|
||||
|
||||
Like Rust, a `TRY` macro is also provided that comes in handy when writing code that calls a lot of functions returning a `Result`.
|
||||
|
||||
the `TRY` macro will simply call its argument and short-cirtcuit the function returning an `Err(E)` if the operation returned an error `Result`:
|
||||
|
||||
```
|
||||
Result<void, IoError> copy(int srcFd, const char* dstFile) {
|
||||
|
||||
auto fd = TRY(open(dstFile));
|
||||
auto data = TRY(read(srcFd));
|
||||
TRY(write(fd, data));
|
||||
|
||||
return Ok();
|
||||
}
|
||||
```
|
||||
|
||||
Note that this macro uses a special extension called *compound statement* only supported by gcc and clang
|
||||
910
third_party/result/include/result.hpp
vendored
910
third_party/result/include/result.hpp
vendored
|
|
@ -1,910 +0,0 @@
|
|||
/*
|
||||
Mathieu Stefani, 03 mai 2016
|
||||
|
||||
This header provides a Result type that can be used to replace exceptions in code
|
||||
that has to handle error.
|
||||
|
||||
Result<T, E> can be used to return and propagate an error to the caller. Result<T, E> is an algebraic
|
||||
data type that can either Ok(T) to represent success or Err(E) to represent an error.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
#include <type_traits>
|
||||
|
||||
namespace types {
|
||||
template<typename T>
|
||||
struct Ok {
|
||||
Ok(const T& val) : val(val) { }
|
||||
Ok(T&& val) : val(std::move(val)) { }
|
||||
|
||||
T val;
|
||||
};
|
||||
|
||||
template<>
|
||||
struct Ok<void> { };
|
||||
|
||||
template<typename E>
|
||||
struct Err {
|
||||
Err(const E& val) : val(val) { }
|
||||
Err(E&& val) : val(std::move(val)) { }
|
||||
|
||||
E val;
|
||||
};
|
||||
}
|
||||
|
||||
template<typename T, typename CleanT = typename std::decay<T>::type>
|
||||
types::Ok<CleanT> Ok(T&& val) {
|
||||
return types::Ok<CleanT>(std::forward<T>(val));
|
||||
}
|
||||
|
||||
inline types::Ok<void> Ok() {
|
||||
return types::Ok<void>();
|
||||
}
|
||||
|
||||
template<typename E, typename CleanE = typename std::decay<E>::type>
|
||||
types::Err<CleanE> Err(E&& val) {
|
||||
return types::Err<CleanE>(std::forward<E>(val));
|
||||
}
|
||||
|
||||
namespace Rust {
|
||||
template<typename T, typename E> struct Result;
|
||||
}
|
||||
|
||||
namespace details {
|
||||
|
||||
template<typename ...> struct void_t { typedef void type; };
|
||||
|
||||
namespace impl {
|
||||
template<typename Func> struct result_of;
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct result_of<Ret (Cls::*)(Args...)> : public result_of<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename... Args>
|
||||
struct result_of<Ret (Args...)> {
|
||||
typedef Ret type;
|
||||
};
|
||||
}
|
||||
|
||||
template<typename Func>
|
||||
struct result_of : public impl::result_of<decltype(&Func::operator())> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct result_of<Ret (Cls::*) (Args...) const> {
|
||||
typedef Ret type;
|
||||
};
|
||||
|
||||
template<typename Ret, typename... Args>
|
||||
struct result_of<Ret (*)(Args...)> {
|
||||
typedef Ret type;
|
||||
};
|
||||
|
||||
template<typename R>
|
||||
struct ResultOkType { typedef typename std::decay<R>::type type; };
|
||||
|
||||
template<typename T, typename E>
|
||||
struct ResultOkType<Rust::Result<T, E>> {
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<typename R>
|
||||
struct ResultErrType { typedef R type; };
|
||||
|
||||
template<typename T, typename E>
|
||||
struct ResultErrType<Rust::Result<T, E>> {
|
||||
typedef typename std::remove_reference<E>::type type;
|
||||
};
|
||||
|
||||
template<typename R> struct IsResult : public std::false_type { };
|
||||
template<typename T, typename E>
|
||||
struct IsResult<Rust::Result<T, E>> : public std::true_type { };
|
||||
|
||||
namespace ok {
|
||||
|
||||
namespace impl {
|
||||
|
||||
template<typename T> struct Map;
|
||||
|
||||
template<typename Ret, typename Cls, typename Arg>
|
||||
struct Map<Ret (Cls::*)(Arg) const> : public Map<Ret (Arg)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename Arg>
|
||||
struct Map<Ret (Cls::*)(Arg)> : public Map<Ret (Arg)> { };
|
||||
|
||||
// General implementation
|
||||
template<typename Ret, typename Arg>
|
||||
struct Map<Ret (Arg)> {
|
||||
|
||||
static_assert(!IsResult<Ret>::value,
|
||||
"Can not map a callback returning a Result, use andThen instead");
|
||||
|
||||
template<typename T, typename E, typename Func>
|
||||
static Rust::Result<Ret, E> map(const Rust::Result<T, E>& result, Func func) {
|
||||
|
||||
static_assert(
|
||||
std::is_same<T, Arg>::value ||
|
||||
std::is_convertible<T, Arg>::value,
|
||||
"Incompatible types detected");
|
||||
|
||||
if (result.isOk()) {
|
||||
auto res = func(result.storage().template get<T>());
|
||||
return types::Ok<Ret>(std::move(res));
|
||||
}
|
||||
|
||||
return types::Err<E>(result.storage().template get<E>());
|
||||
}
|
||||
};
|
||||
|
||||
// Specialization for callback returning void
|
||||
template<typename Arg>
|
||||
struct Map<void (Arg)> {
|
||||
|
||||
template<typename T, typename E, typename Func>
|
||||
static Rust::Result<void, E> map(const Rust::Result<T, E>& result, Func func) {
|
||||
|
||||
if (result.isOk()) {
|
||||
func(result.storage().template get<T>());
|
||||
return types::Ok<void>();
|
||||
}
|
||||
|
||||
return types::Err<E>(result.storage().template get<E>());
|
||||
}
|
||||
};
|
||||
|
||||
// Specialization for a void Result
|
||||
template<typename Ret>
|
||||
struct Map<Ret (void)> {
|
||||
|
||||
template<typename T, typename E, typename Func>
|
||||
static Rust::Result<Ret, E> map(const Rust::Result<T, E>& result, Func func) {
|
||||
static_assert(std::is_same<T, void>::value,
|
||||
"Can not map a void callback on a non-void Result");
|
||||
|
||||
if (result.isOk()) {
|
||||
auto ret = func();
|
||||
return types::Ok<Ret>(std::move(ret));
|
||||
}
|
||||
|
||||
return types::Err<E>(result.storage().template get<E>());
|
||||
}
|
||||
};
|
||||
|
||||
// Specialization for callback returning void on a void Result
|
||||
template<>
|
||||
struct Map<void (void)> {
|
||||
|
||||
template<typename T, typename E, typename Func>
|
||||
static Rust::Result<void, E> map(const Rust::Result<T, E>& result, Func func) {
|
||||
static_assert(std::is_same<T, void>::value,
|
||||
"Can not map a void callback on a non-void Result");
|
||||
|
||||
if (result.isOk()) {
|
||||
func();
|
||||
return types::Ok<void>();
|
||||
}
|
||||
|
||||
return types::Err<E>(result.storage().template get<E>());
|
||||
}
|
||||
};
|
||||
|
||||
// General specialization for a callback returning a Result
|
||||
template<typename U, typename E, typename Arg>
|
||||
struct Map<Rust::Result<U, E> (Arg)> {
|
||||
|
||||
template<typename T, typename Func>
|
||||
static Rust::Result<U, E> map(const Rust::Result<T, E>& result, Func func) {
|
||||
static_assert(
|
||||
std::is_same<T, Arg>::value ||
|
||||
std::is_convertible<T, Arg>::value,
|
||||
"Incompatible types detected");
|
||||
|
||||
if (result.isOk()) {
|
||||
auto res = func(result.storage().template get<T>());
|
||||
return res;
|
||||
}
|
||||
|
||||
return types::Err<E>(result.storage().template get<E>());
|
||||
}
|
||||
};
|
||||
|
||||
// Specialization for a void callback returning a Result
|
||||
template<typename U, typename E>
|
||||
struct Map<Rust::Result<U, E> (void)> {
|
||||
|
||||
template<typename T, typename Func>
|
||||
static Rust::Result<U, E> map(const Rust::Result<T, E>& result, Func func) {
|
||||
static_assert(std::is_same<T, void>::value, "Can not call a void-callback on a non-void Result");
|
||||
|
||||
if (result.isOk()) {
|
||||
auto res = func();
|
||||
return res;
|
||||
}
|
||||
|
||||
return types::Err<E>(result.storage().template get<E>());
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
template<typename Func> struct Map : public impl::Map<decltype(&Func::operator())> { };
|
||||
|
||||
template<typename Ret, typename... Args>
|
||||
struct Map<Ret (*) (Args...)> : public impl::Map<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Map<Ret (Cls::*) (Args...)> : public impl::Map<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Map<Ret (Cls::*) (Args...) const> : public impl::Map<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename... Args>
|
||||
struct Map<std::function<Ret (Args...)>> : public impl::Map<Ret (Args...)> { };
|
||||
|
||||
} // namespace ok
|
||||
|
||||
|
||||
namespace err {
|
||||
|
||||
namespace impl {
|
||||
|
||||
template<typename T> struct Map;
|
||||
|
||||
template<typename Ret, typename Cls, typename Arg>
|
||||
struct Map<Ret (Cls::*)(Arg) const> {
|
||||
|
||||
static_assert(!IsResult<Ret>::value,
|
||||
"Can not map a callback returning a Result, use orElse instead");
|
||||
|
||||
template<typename T, typename E, typename Func>
|
||||
static Rust::Result<T, Ret> map(const Rust::Result<T, E>& result, Func func) {
|
||||
if (result.isErr()) {
|
||||
auto res = func(result.storage().template get<E>());
|
||||
return types::Err<Ret>(res);
|
||||
}
|
||||
|
||||
return types::Ok<T>(result.storage().template get<T>());
|
||||
}
|
||||
|
||||
template<typename E, typename Func>
|
||||
static Rust::Result<void, Ret> map(const Rust::Result<void, E>& result, Func func) {
|
||||
if (result.isErr()) {
|
||||
auto res = func(result.storage().template get<E>());
|
||||
return types::Err<Ret>(res);
|
||||
}
|
||||
|
||||
return types::Ok<void>();
|
||||
}
|
||||
|
||||
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
template<typename Func> struct Map : public impl::Map<decltype(&Func::operator())> { };
|
||||
|
||||
} // namespace err;
|
||||
|
||||
namespace And {
|
||||
|
||||
namespace impl {
|
||||
|
||||
template<typename Func> struct Then;
|
||||
|
||||
template<typename Ret, typename... Args>
|
||||
struct Then<Ret (*)(Args...)> : public Then<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Then<Ret (Cls::*)(Args...)> : public Then<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Then<Ret (Cls::*)(Args...) const> : public Then<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Arg>
|
||||
struct Then<Ret (Arg)> {
|
||||
static_assert(std::is_same<Ret, void>::value,
|
||||
"then() should not return anything, use map() instead");
|
||||
|
||||
template<typename T, typename E, typename Func>
|
||||
static Rust::Result<T, E> then(const Rust::Result<T, E>& result, Func func) {
|
||||
if (result.isOk()) {
|
||||
func(result.storage().template get<T>());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename Ret>
|
||||
struct Then<Ret (void)> {
|
||||
static_assert(std::is_same<Ret, void>::value,
|
||||
"then() should not return anything, use map() instead");
|
||||
|
||||
template<typename T, typename E, typename Func>
|
||||
static Rust::Result<T, E> then(const Rust::Result<T, E>& result, Func func) {
|
||||
static_assert(std::is_same<T, void>::value, "Can not call a void-callback on a non-void Result");
|
||||
|
||||
if (result.isOk()) {
|
||||
func();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
} // namespace impl
|
||||
|
||||
template<typename Func>
|
||||
struct Then : public impl::Then<decltype(&Func::operator())> { };
|
||||
|
||||
template<typename Ret, typename... Args>
|
||||
struct Then<Ret (*) (Args...)> : public impl::Then<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Then<Ret (Cls::*)(Args...)> : public impl::Then<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Then<Ret (Cls::*)(Args...) const> : public impl::Then<Ret (Args...)> { };
|
||||
|
||||
} // namespace And
|
||||
|
||||
namespace Or {
|
||||
|
||||
namespace impl {
|
||||
|
||||
template<typename Func> struct Else;
|
||||
|
||||
template<typename Ret, typename... Args>
|
||||
struct Else<Ret (*)(Args...)> : public Else<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Else<Ret (Cls::*)(Args...)> : public Else<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Else<Ret (Cls::*)(Args...) const> : public Else<Ret (Args...)> { };
|
||||
|
||||
template<typename T, typename F, typename Arg>
|
||||
struct Else<Rust::Result<T, F> (Arg)> {
|
||||
|
||||
template<typename E, typename Func>
|
||||
static Rust::Result<T, F> orElse(const Rust::Result<T, E>& result, Func func) {
|
||||
static_assert(
|
||||
std::is_same<E, Arg>::value ||
|
||||
std::is_convertible<E, Arg>::value,
|
||||
"Incompatible types detected");
|
||||
|
||||
if (result.isErr()) {
|
||||
auto res = func(result.storage().template get<E>());
|
||||
return res;
|
||||
}
|
||||
|
||||
return types::Ok<T>(result.storage().template get<T>());
|
||||
}
|
||||
|
||||
template<typename E, typename Func>
|
||||
static Rust::Result<void, F> orElse(const Rust::Result<void, E>& result, Func func) {
|
||||
if (result.isErr()) {
|
||||
auto res = func(result.storage().template get<E>());
|
||||
return res;
|
||||
}
|
||||
|
||||
return types::Ok<void>();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
template<typename T, typename F>
|
||||
struct Else<Rust::Result<T, F> (void)> {
|
||||
|
||||
template<typename E, typename Func>
|
||||
static Rust::Result<T, F> orElse(const Rust::Result<T, E>& result, Func func) {
|
||||
static_assert(std::is_same<T, void>::value,
|
||||
"Can not call a void-callback on a non-void Result");
|
||||
|
||||
if (result.isErr()) {
|
||||
auto res = func();
|
||||
return res;
|
||||
}
|
||||
|
||||
return types::Ok<T>(result.storage().template get<T>());
|
||||
}
|
||||
|
||||
template<typename E, typename Func>
|
||||
static Rust::Result<void, F> orElse(const Rust::Result<void, E>& result, Func func) {
|
||||
if (result.isErr()) {
|
||||
auto res = func();
|
||||
return res;
|
||||
}
|
||||
|
||||
return types::Ok<void>();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
template<typename Func>
|
||||
struct Else : public impl::Else<decltype(&Func::operator())> { };
|
||||
|
||||
template<typename Ret, typename... Args>
|
||||
struct Else<Ret (*) (Args...)> : public impl::Else<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Else<Ret (Cls::*)(Args...)> : public impl::Else<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Else<Ret (Cls::*)(Args...) const> : public impl::Else<Ret (Args...)> { };
|
||||
|
||||
} // namespace Or
|
||||
|
||||
namespace Other {
|
||||
|
||||
namespace impl {
|
||||
|
||||
template<typename Func> struct Wise;
|
||||
|
||||
template<typename Ret, typename... Args>
|
||||
struct Wise<Ret (*)(Args...)> : public Wise<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Wise<Ret (Cls::*)(Args...)> : public Wise<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Wise<Ret (Cls::*)(Args...) const> : public Wise<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Arg>
|
||||
struct Wise<Ret (Arg)> {
|
||||
|
||||
template<typename T, typename E, typename Func>
|
||||
static Rust::Result<T, E> otherwise(const Rust::Result<T, E>& result, Func func) {
|
||||
static_assert(
|
||||
std::is_same<E, Arg>::value ||
|
||||
std::is_convertible<E, Arg>::value,
|
||||
"Incompatible types detected");
|
||||
|
||||
static_assert(std::is_same<Ret, void>::value,
|
||||
"callback should not return anything, use mapError() for that");
|
||||
|
||||
if (result.isErr()) {
|
||||
func(result.storage().template get<E>());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
} // namespace impl
|
||||
|
||||
template<typename Func>
|
||||
struct Wise : public impl::Wise<decltype(&Func::operator())> { };
|
||||
|
||||
template<typename Ret, typename... Args>
|
||||
struct Wise<Ret (*) (Args...)> : public impl::Wise<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Wise<Ret (Cls::*)(Args...)> : public impl::Wise<Ret (Args...)> { };
|
||||
|
||||
template<typename Ret, typename Cls, typename... Args>
|
||||
struct Wise<Ret (Cls::*)(Args...) const> : public impl::Wise<Ret (Args...)> { };
|
||||
|
||||
} // namespace Other
|
||||
|
||||
template<typename T, typename E, typename Func,
|
||||
typename Ret =
|
||||
Rust::Result<
|
||||
typename details::ResultOkType<
|
||||
typename details::result_of<Func>::type
|
||||
>::type,
|
||||
E>
|
||||
>
|
||||
Ret map(const Rust::Result<T, E>& result, Func func) {
|
||||
return ok::Map<Func>::map(result, func);
|
||||
}
|
||||
|
||||
template<typename T, typename E, typename Func,
|
||||
typename Ret =
|
||||
Rust::Result<T,
|
||||
typename details::ResultErrType<
|
||||
typename details::result_of<Func>::type
|
||||
>::type
|
||||
>
|
||||
>
|
||||
Ret mapError(const Rust::Result<T, E>& result, Func func) {
|
||||
return err::Map<Func>::map(result, func);
|
||||
}
|
||||
|
||||
template<typename T, typename E, typename Func>
|
||||
Rust::Result<T, E> then(const Rust::Result<T, E>& result, Func func) {
|
||||
return And::Then<Func>::then(result, func);
|
||||
}
|
||||
|
||||
template<typename T, typename E, typename Func>
|
||||
Rust::Result<T, E> otherwise(const Rust::Result<T, E>& result, Func func) {
|
||||
return Other::Wise<Func>::otherwise(result, func);
|
||||
}
|
||||
|
||||
template<typename T, typename E, typename Func,
|
||||
typename Ret =
|
||||
Rust::Result<T,
|
||||
typename details::ResultErrType<
|
||||
typename details::result_of<Func>::type
|
||||
>::type
|
||||
>
|
||||
>
|
||||
Ret orElse(const Rust::Result<T, E>& result, Func func) {
|
||||
return Or::Else<Func>::orElse(result, func);
|
||||
}
|
||||
|
||||
struct ok_tag { };
|
||||
struct err_tag { };
|
||||
|
||||
template<typename T, typename E>
|
||||
struct Storage {
|
||||
static constexpr size_t Size = sizeof(T) > sizeof(E) ? sizeof(T) : sizeof(E);
|
||||
static constexpr size_t Align = sizeof(T) > sizeof(E) ? alignof(T) : alignof(E);
|
||||
|
||||
typedef typename std::aligned_storage<Size, Align>::type type;
|
||||
|
||||
Storage()
|
||||
: initialized_(false)
|
||||
{ }
|
||||
|
||||
void construct(types::Ok<T> ok)
|
||||
{
|
||||
new (&storage_) T(ok.val);
|
||||
initialized_ = true;
|
||||
}
|
||||
void construct(types::Err<E> err)
|
||||
{
|
||||
new (&storage_) E(err.val);
|
||||
initialized_ = true;
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
void rawConstruct(U&& val) {
|
||||
typedef typename std::decay<U>::type CleanU;
|
||||
|
||||
new (&storage_) CleanU(std::forward<U>(val));
|
||||
initialized_ = true;
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
const U& get() const {
|
||||
return *reinterpret_cast<const U *>(&storage_);
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
U& get() {
|
||||
return *reinterpret_cast<U *>(&storage_);
|
||||
}
|
||||
|
||||
void destroy(ok_tag) {
|
||||
if (initialized_) {
|
||||
get<T>().~T();
|
||||
initialized_ = false;
|
||||
}
|
||||
}
|
||||
|
||||
void destroy(err_tag) {
|
||||
if (initialized_) {
|
||||
get<E>().~E();
|
||||
initialized_ = false;
|
||||
}
|
||||
}
|
||||
|
||||
type storage_;
|
||||
bool initialized_;
|
||||
};
|
||||
|
||||
template<typename E>
|
||||
struct Storage<void, E> {
|
||||
typedef typename std::aligned_storage<sizeof(E), alignof(E)>::type type;
|
||||
|
||||
void construct(types::Ok<void>)
|
||||
{
|
||||
initialized_ = true;
|
||||
}
|
||||
|
||||
void construct(types::Err<E> err)
|
||||
{
|
||||
new (&storage_) E(err.val);
|
||||
initialized_ = true;
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
void rawConstruct(U&& val) {
|
||||
typedef typename std::decay<U>::type CleanU;
|
||||
|
||||
new (&storage_) CleanU(std::forward<U>(val));
|
||||
initialized_ = true;
|
||||
}
|
||||
|
||||
void destroy(ok_tag) { initialized_ = false; }
|
||||
void destroy(err_tag) {
|
||||
if (initialized_) {
|
||||
get<E>().~E(); initialized_ = false;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
const U& get() const {
|
||||
return *reinterpret_cast<const U *>(&storage_);
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
U& get() {
|
||||
return *reinterpret_cast<U *>(&storage_);
|
||||
}
|
||||
|
||||
type storage_;
|
||||
bool initialized_;
|
||||
};
|
||||
|
||||
template<typename T, typename E>
|
||||
struct Constructor {
|
||||
|
||||
static void move(Storage<T, E>&& src, Storage<T, E>& dst, ok_tag) {
|
||||
dst.rawConstruct(std::move(src.template get<T>()));
|
||||
src.destroy(ok_tag());
|
||||
}
|
||||
|
||||
static void copy(const Storage<T, E>& src, Storage<T, E>& dst, ok_tag) {
|
||||
dst.rawConstruct(src.template get<T>());
|
||||
}
|
||||
|
||||
static void move(Storage<T, E>&& src, Storage<T, E>& dst, err_tag) {
|
||||
dst.rawConstruct(std::move(src.template get<E>()));
|
||||
src.destroy(err_tag());
|
||||
}
|
||||
|
||||
static void copy(const Storage<T, E>& src, Storage<T, E>& dst, err_tag) {
|
||||
dst.rawConstruct(src.template get<E>());
|
||||
}
|
||||
};
|
||||
|
||||
template<typename E>
|
||||
struct Constructor<void, E> {
|
||||
static void move(Storage<void, E>&& src, Storage<void, E>& dst, ok_tag) {
|
||||
}
|
||||
|
||||
static void copy(const Storage<void, E>& src, Storage<void, E>& dst, ok_tag) {
|
||||
}
|
||||
|
||||
static void move(Storage<void, E>&& src, Storage<void, E>& dst, err_tag) {
|
||||
dst.rawConstruct(std::move(src.template get<E>()));
|
||||
src.destroy(err_tag());
|
||||
}
|
||||
|
||||
static void copy(const Storage<void, E>& src, Storage<void, E>& dst, err_tag) {
|
||||
dst.rawConstruct(src.template get<E>());
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace details
|
||||
|
||||
namespace rpog {
|
||||
|
||||
template<typename T, typename = void> struct EqualityComparable : std::false_type { };
|
||||
|
||||
template<typename T>
|
||||
struct EqualityComparable<T,
|
||||
typename std::enable_if<
|
||||
true,
|
||||
typename details::void_t<decltype(std::declval<T>() == std::declval<T>())>::type
|
||||
>::type
|
||||
> : std::true_type
|
||||
{
|
||||
};
|
||||
|
||||
|
||||
} // namespace rpog
|
||||
|
||||
namespace Rust {
|
||||
template<typename T, typename E>
|
||||
struct Result {
|
||||
|
||||
static_assert(!std::is_same<E, void>::value, "void error type is not allowed");
|
||||
|
||||
typedef details::Storage<T, E> storage_type;
|
||||
|
||||
Result(types::Ok<T> ok)
|
||||
: ok_(true)
|
||||
{
|
||||
storage_.construct(std::move(ok));
|
||||
}
|
||||
|
||||
Result(types::Err<E> err)
|
||||
: ok_(false)
|
||||
{
|
||||
storage_.construct(std::move(err));
|
||||
}
|
||||
|
||||
Result(Result&& other) {
|
||||
if (other.isOk()) {
|
||||
details::Constructor<T, E>::move(std::move(other.storage_), storage_, details::ok_tag());
|
||||
ok_ = true;
|
||||
} else {
|
||||
details::Constructor<T, E>::move(std::move(other.storage_), storage_, details::err_tag());
|
||||
ok_ = false;
|
||||
}
|
||||
}
|
||||
|
||||
Result(const Result& other) {
|
||||
if (other.isOk()) {
|
||||
details::Constructor<T, E>::copy(other.storage_, storage_, details::ok_tag());
|
||||
ok_ = true;
|
||||
} else {
|
||||
details::Constructor<T, E>::copy(other.storage_, storage_, details::err_tag());
|
||||
ok_ = false;
|
||||
}
|
||||
}
|
||||
|
||||
~Result() {
|
||||
if (ok_)
|
||||
storage_.destroy(details::ok_tag());
|
||||
else
|
||||
storage_.destroy(details::err_tag());
|
||||
}
|
||||
|
||||
bool isOk() const {
|
||||
return ok_;
|
||||
}
|
||||
|
||||
bool isErr() const {
|
||||
return !ok_;
|
||||
}
|
||||
|
||||
T expect(const char* str) const {
|
||||
if (!isOk()) {
|
||||
std::fprintf(stderr, "%s\n", str);
|
||||
std::terminate();
|
||||
}
|
||||
return expect_impl(std::is_same<T, void>());
|
||||
}
|
||||
|
||||
template<typename Func,
|
||||
typename Ret =
|
||||
Result<
|
||||
typename details::ResultOkType<
|
||||
typename details::result_of<Func>::type
|
||||
>::type,
|
||||
E>
|
||||
>
|
||||
Ret map(Func func) const {
|
||||
return details::map(*this, func);
|
||||
}
|
||||
|
||||
template<typename Func,
|
||||
typename Ret =
|
||||
Result<T,
|
||||
typename details::ResultErrType<
|
||||
typename details::result_of<Func>::type
|
||||
>::type
|
||||
>
|
||||
>
|
||||
Ret mapError(Func func) const {
|
||||
return details::mapError(*this, func);
|
||||
}
|
||||
|
||||
template<typename Func>
|
||||
Result<T, E> then(Func func) const {
|
||||
return details::then(*this, func);
|
||||
}
|
||||
|
||||
template<typename Func>
|
||||
Result<T, E> otherwise(Func func) const {
|
||||
return details::otherwise(*this, func);
|
||||
}
|
||||
|
||||
template<typename Func,
|
||||
typename Ret =
|
||||
Result<T,
|
||||
typename details::ResultErrType<
|
||||
typename details::result_of<Func>::type
|
||||
>::type
|
||||
>
|
||||
>
|
||||
Ret orElse(Func func) const {
|
||||
return details::orElse(*this, func);
|
||||
}
|
||||
|
||||
storage_type& storage() {
|
||||
return storage_;
|
||||
}
|
||||
|
||||
const storage_type& storage() const {
|
||||
return storage_;
|
||||
}
|
||||
|
||||
template<typename U = T>
|
||||
typename std::enable_if<
|
||||
!std::is_same<U, void>::value,
|
||||
U
|
||||
>::type
|
||||
unwrapOr(const U& defaultValue) const {
|
||||
if (isOk()) {
|
||||
return storage().template get<U>();
|
||||
}
|
||||
return defaultValue;
|
||||
}
|
||||
|
||||
template<typename U = T>
|
||||
typename std::enable_if<
|
||||
!std::is_same<U, void>::value,
|
||||
U
|
||||
>::type
|
||||
unwrap() const {
|
||||
if (isOk()) {
|
||||
return storage().template get<U>();
|
||||
}
|
||||
|
||||
std::fprintf(stderr, "Attempting to unwrap an error Result\n");
|
||||
std::terminate();
|
||||
}
|
||||
|
||||
E unwrapErr() const {
|
||||
if (isErr()) {
|
||||
return storage().template get<E>();
|
||||
}
|
||||
|
||||
std::fprintf(stderr, "Attempting to unwrapErr an ok Result\n");
|
||||
std::terminate();
|
||||
}
|
||||
|
||||
private:
|
||||
T expect_impl(std::true_type) const { }
|
||||
T expect_impl(std::false_type) const { return storage_.template get<T>(); }
|
||||
|
||||
bool ok_;
|
||||
storage_type storage_;
|
||||
};
|
||||
|
||||
template<typename T, typename E>
|
||||
bool operator==(const Rust::Result<T, E>& lhs, const Rust::Result<T, E>& rhs) {
|
||||
static_assert(rpog::EqualityComparable<T>::value, "T must be EqualityComparable for Result to be comparable");
|
||||
static_assert(rpog::EqualityComparable<E>::value, "E must be EqualityComparable for Result to be comparable");
|
||||
|
||||
if (lhs.isOk() && rhs.isOk()) {
|
||||
return lhs.storage().template get<T>() == rhs.storage().template get<T>();
|
||||
}
|
||||
if (lhs.isErr() && rhs.isErr()) {
|
||||
return lhs.storage().template get<E>() == rhs.storage().template get<E>();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T, typename E>
|
||||
bool operator==(const Rust::Result<T, E>& lhs, types::Ok<T> ok) {
|
||||
static_assert(rpog::EqualityComparable<T>::value, "T must be EqualityComparable for Result to be comparable");
|
||||
|
||||
if (!lhs.isOk()) return false;
|
||||
|
||||
return lhs.storage().template get<T>() == ok.val;
|
||||
}
|
||||
|
||||
template<typename E>
|
||||
bool operator==(const Rust::Result<void, E>& lhs, types::Ok<void>) {
|
||||
return lhs.isOk();
|
||||
}
|
||||
|
||||
template<typename T, typename E>
|
||||
bool operator==(const Rust::Result<T, E>& lhs, types::Err<E> err) {
|
||||
static_assert(rpog::EqualityComparable<E>::value, "E must be EqualityComparable for Result to be comparable");
|
||||
if (!lhs.isErr()) return false;
|
||||
|
||||
return lhs.storage().template get<E>() == err.val;
|
||||
}
|
||||
} // end namespace Rust
|
||||
|
||||
#define TRY(...) \
|
||||
({ \
|
||||
auto res = __VA_ARGS__; \
|
||||
if (!res.isOk()) { \
|
||||
typedef details::ResultErrType<decltype(res)>::type E; \
|
||||
return types::Err<E>(res.storage().get<E>()); \
|
||||
} \
|
||||
typedef details::ResultOkType<decltype(res)>::type T; \
|
||||
res.storage().get<T>(); \
|
||||
})
|
||||
Loading…
Add table
Add a link
Reference in a new issue