2014-06-27 22:18:56 +02:00
|
|
|
// Copyright 2014 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
2014-09-12 00:42:59 +02:00
|
|
|
#include <memory>
|
|
|
|
|
2014-06-27 22:18:56 +02:00
|
|
|
#include "common/common_types.h"
|
2014-11-10 23:36:32 +01:00
|
|
|
#include "common/string_util.h"
|
2014-09-12 00:42:59 +02:00
|
|
|
#include "common/bit_field.h"
|
|
|
|
|
2014-12-15 08:03:17 +01:00
|
|
|
#include "core/file_sys/file_backend.h"
|
2014-12-15 07:59:29 +01:00
|
|
|
#include "core/file_sys/directory_backend.h"
|
2014-06-27 22:18:56 +02:00
|
|
|
|
2014-11-10 23:36:32 +01:00
|
|
|
#include "core/mem_map.h"
|
2014-06-27 22:18:56 +02:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// FileSys namespace
|
|
|
|
|
|
|
|
namespace FileSys {
|
|
|
|
|
2014-11-10 23:36:32 +01:00
|
|
|
// Path string type
|
|
|
|
enum LowPathType : u32 {
|
|
|
|
Invalid = 0,
|
|
|
|
Empty = 1,
|
|
|
|
Binary = 2,
|
|
|
|
Char = 3,
|
|
|
|
Wchar = 4
|
|
|
|
};
|
|
|
|
|
2014-09-12 00:42:59 +02:00
|
|
|
union Mode {
|
|
|
|
u32 hex;
|
|
|
|
BitField<0, 1, u32> read_flag;
|
|
|
|
BitField<1, 1, u32> write_flag;
|
|
|
|
BitField<2, 1, u32> create_flag;
|
|
|
|
};
|
|
|
|
|
2014-11-10 23:36:32 +01:00
|
|
|
class Path {
|
|
|
|
public:
|
|
|
|
|
|
|
|
Path():
|
|
|
|
type(Invalid)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
Path(LowPathType type, u32 size, u32 pointer):
|
|
|
|
type(type)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case Binary:
|
|
|
|
{
|
|
|
|
u8* data = Memory::GetPointer(pointer);
|
|
|
|
binary = std::vector<u8>(data, data + size);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Char:
|
|
|
|
{
|
|
|
|
const char* data = reinterpret_cast<const char*>(Memory::GetPointer(pointer));
|
|
|
|
string = std::string(data, size - 1); // Data is always null-terminated.
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Wchar:
|
|
|
|
{
|
|
|
|
const char16_t* data = reinterpret_cast<const char16_t*>(Memory::GetPointer(pointer));
|
|
|
|
u16str = std::u16string(data, size/2 - 1); // Data is always null-terminated.
|
|
|
|
break;
|
|
|
|
}
|
2014-11-27 11:35:27 +01:00
|
|
|
default:
|
|
|
|
break;
|
2014-11-10 23:36:32 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
LowPathType GetType() const {
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
2014-11-14 01:26:33 +01:00
|
|
|
/**
|
|
|
|
* Gets the string representation of the path for debugging
|
|
|
|
* @return String representation of the path for debugging
|
|
|
|
*/
|
|
|
|
const std::string DebugStr() const {
|
|
|
|
switch (GetType()) {
|
|
|
|
case Invalid:
|
|
|
|
return "[Invalid]";
|
|
|
|
case Empty:
|
|
|
|
return "[Empty]";
|
|
|
|
case Binary:
|
|
|
|
{
|
|
|
|
std::stringstream res;
|
|
|
|
res << "[Binary: ";
|
|
|
|
for (unsigned byte : binary)
|
|
|
|
res << std::hex << std::setw(2) << std::setfill('0') << byte;
|
|
|
|
res << ']';
|
|
|
|
return res.str();
|
|
|
|
}
|
|
|
|
case Char:
|
|
|
|
return "[Char: " + AsString() + ']';
|
|
|
|
case Wchar:
|
|
|
|
return "[Wchar: " + AsString() + ']';
|
|
|
|
default:
|
2014-12-06 02:53:49 +01:00
|
|
|
// TODO(yuriks): Add assert
|
|
|
|
LOG_ERROR(Service_FS, "LowPathType cannot be converted to string!");
|
2014-11-14 01:26:33 +01:00
|
|
|
return {};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-10 23:36:32 +01:00
|
|
|
const std::string AsString() const {
|
|
|
|
switch (GetType()) {
|
|
|
|
case Char:
|
|
|
|
return string;
|
|
|
|
case Wchar:
|
|
|
|
return Common::UTF16ToUTF8(u16str);
|
|
|
|
case Empty:
|
|
|
|
return {};
|
|
|
|
default:
|
2014-12-06 02:53:49 +01:00
|
|
|
// TODO(yuriks): Add assert
|
|
|
|
LOG_ERROR(Service_FS, "LowPathType cannot be converted to string!");
|
2014-11-10 23:36:32 +01:00
|
|
|
return {};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const std::u16string AsU16Str() const {
|
|
|
|
switch (GetType()) {
|
|
|
|
case Char:
|
|
|
|
return Common::UTF8ToUTF16(string);
|
|
|
|
case Wchar:
|
|
|
|
return u16str;
|
|
|
|
case Empty:
|
|
|
|
return {};
|
|
|
|
default:
|
2014-12-06 02:53:49 +01:00
|
|
|
// TODO(yuriks): Add assert
|
|
|
|
LOG_ERROR(Service_FS, "LowPathType cannot be converted to u16string!");
|
2014-11-10 23:36:32 +01:00
|
|
|
return {};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const std::vector<u8> AsBinary() const {
|
|
|
|
switch (GetType()) {
|
|
|
|
case Binary:
|
|
|
|
return binary;
|
|
|
|
case Char:
|
|
|
|
return std::vector<u8>(string.begin(), string.end());
|
|
|
|
case Wchar:
|
|
|
|
return std::vector<u8>(u16str.begin(), u16str.end());
|
|
|
|
case Empty:
|
|
|
|
return {};
|
|
|
|
default:
|
2014-12-06 02:53:49 +01:00
|
|
|
// TODO(yuriks): Add assert
|
|
|
|
LOG_ERROR(Service_FS, "LowPathType cannot be converted to binary!");
|
2014-11-10 23:36:32 +01:00
|
|
|
return {};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
LowPathType type;
|
|
|
|
std::vector<u8> binary;
|
|
|
|
std::string string;
|
|
|
|
std::u16string u16str;
|
|
|
|
};
|
|
|
|
|
2014-12-15 05:51:38 +01:00
|
|
|
class ArchiveBackend : NonCopyable {
|
2014-06-27 22:18:56 +02:00
|
|
|
public:
|
2014-12-15 05:51:38 +01:00
|
|
|
virtual ~ArchiveBackend() { }
|
2014-06-27 22:18:56 +02:00
|
|
|
|
|
|
|
/**
|
2014-12-15 05:44:04 +01:00
|
|
|
* Get a descriptive name for the archive (e.g. "RomFS", "SaveData", etc.)
|
2014-06-27 22:18:56 +02:00
|
|
|
*/
|
2014-12-15 05:44:04 +01:00
|
|
|
virtual std::string GetName() const = 0;
|
2014-06-27 22:18:56 +02:00
|
|
|
|
2014-09-12 00:42:59 +02:00
|
|
|
/**
|
|
|
|
* Open a file specified by its path, using the specified mode
|
|
|
|
* @param path Path relative to the archive
|
|
|
|
* @param mode Mode to open the file with
|
|
|
|
* @return Opened file, or nullptr
|
|
|
|
*/
|
2014-12-15 08:03:17 +01:00
|
|
|
virtual std::unique_ptr<FileBackend> OpenFile(const Path& path, const Mode mode) const = 0;
|
2014-09-12 00:42:59 +02:00
|
|
|
|
2014-11-11 19:37:26 +01:00
|
|
|
/**
|
|
|
|
* Delete a file specified by its path
|
|
|
|
* @param path Path relative to the archive
|
|
|
|
* @return Whether the file could be deleted
|
|
|
|
*/
|
|
|
|
virtual bool DeleteFile(const FileSys::Path& path) const = 0;
|
|
|
|
|
2014-11-24 08:20:04 +01:00
|
|
|
/**
|
|
|
|
* Rename a File specified by its path
|
|
|
|
* @param src_path Source path relative to the archive
|
|
|
|
* @param dest_path Destination path relative to the archive
|
|
|
|
* @return Whether rename succeeded
|
|
|
|
*/
|
|
|
|
virtual bool RenameFile(const FileSys::Path& src_path, const FileSys::Path& dest_path) const = 0;
|
|
|
|
|
2014-11-11 19:37:26 +01:00
|
|
|
/**
|
|
|
|
* Delete a directory specified by its path
|
|
|
|
* @param path Path relative to the archive
|
|
|
|
* @return Whether the directory could be deleted
|
|
|
|
*/
|
|
|
|
virtual bool DeleteDirectory(const FileSys::Path& path) const = 0;
|
|
|
|
|
2014-10-29 06:52:56 +01:00
|
|
|
/**
|
|
|
|
* Create a directory specified by its path
|
|
|
|
* @param path Path relative to the archive
|
|
|
|
* @return Whether the directory could be created
|
|
|
|
*/
|
2014-11-12 01:27:35 +01:00
|
|
|
virtual bool CreateDirectory(const Path& path) const = 0;
|
2014-10-29 06:52:56 +01:00
|
|
|
|
2014-11-24 10:12:58 +01:00
|
|
|
/**
|
|
|
|
* Rename a Directory specified by its path
|
|
|
|
* @param src_path Source path relative to the archive
|
|
|
|
* @param dest_path Destination path relative to the archive
|
|
|
|
* @return Whether rename succeeded
|
|
|
|
*/
|
|
|
|
virtual bool RenameDirectory(const FileSys::Path& src_path, const FileSys::Path& dest_path) const = 0;
|
|
|
|
|
2014-09-12 00:47:05 +02:00
|
|
|
/**
|
|
|
|
* Open a directory specified by its path
|
|
|
|
* @param path Path relative to the archive
|
|
|
|
* @return Opened directory, or nullptr
|
|
|
|
*/
|
2014-12-15 07:59:29 +01:00
|
|
|
virtual std::unique_ptr<DirectoryBackend> OpenDirectory(const Path& path) const = 0;
|
2014-06-27 22:18:56 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace FileSys
|