159 lines
3.8 KiB
C++
159 lines
3.8 KiB
C++
|
|
#include "./memory.hpp"
|
|
|
|
#include "../io/stream.hpp"
|
|
|
|
namespace mijin
|
|
{
|
|
std::vector<FolderEntry> MemoryFileSystemAdapter::listFiles(PathView folder)
|
|
{
|
|
const detail::MemoryFolder* folderObj = findFolder(folder);
|
|
if (folderObj == nullptr)
|
|
{
|
|
return {};
|
|
}
|
|
std::vector<FolderEntry> result;
|
|
result.reserve(folderObj->folders.size() + folderObj->files.size());
|
|
|
|
const Path folderPath(folder);
|
|
for (const auto& [name, subFolder] : folderObj->folders)
|
|
{
|
|
result.emplace_back(folderPath / name, folderInfo(subFolder));
|
|
}
|
|
|
|
for (const auto& [name, file] : folderObj->files)
|
|
{
|
|
result.emplace_back(folderPath / name, fileInfo(file));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
FileInfo MemoryFileSystemAdapter::getFileInfo(PathView file)
|
|
{
|
|
#if 0 // shouldn't be necessary
|
|
// empty means root
|
|
if (file.empty())
|
|
{
|
|
return {
|
|
.path = {},
|
|
.size = root_.folders.size() + root_.files.size(),
|
|
.exists = true,
|
|
.isFolder = true
|
|
};
|
|
}
|
|
#endif
|
|
|
|
const detail::MemoryFolder* folderObj = findFolder(file.getParent());
|
|
if (folderObj == nullptr)
|
|
{
|
|
return {};
|
|
}
|
|
const std::string_view filename = file.getName();
|
|
|
|
if (auto itFolder = folderObj->folders.find(filename); itFolder != folderObj->folders.end())
|
|
{
|
|
return folderInfo(itFolder->second);
|
|
}
|
|
if (auto itFile = folderObj->files.find(filename); itFile != folderObj->files.end())
|
|
{
|
|
return fileInfo(itFile->second);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
StreamError MemoryFileSystemAdapter::open(PathView path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
|
|
{
|
|
if (mode != FileOpenMode::READ)
|
|
{
|
|
return StreamError::IO_ERROR;
|
|
}
|
|
|
|
const detail::MemoryFolder* folderObj = findFolder(path.getParent());
|
|
if (folderObj == nullptr)
|
|
{
|
|
return StreamError::IO_ERROR;
|
|
}
|
|
|
|
auto itFile = folderObj->files.find(path.getName());
|
|
if (itFile == folderObj->files.end())
|
|
{
|
|
return StreamError::IO_ERROR;
|
|
}
|
|
|
|
std::unique_ptr<MemoryStream> stream = std::make_unique<MemoryStream>();
|
|
stream->openRO(itFile->second.data);
|
|
outStream = std::move(stream);
|
|
|
|
return StreamError::SUCCESS;
|
|
}
|
|
|
|
bool MemoryFileSystemAdapter::addFile(PathView path, std::span<const std::uint8_t> data, Overwrite overwrite, CopyData copyData)
|
|
{
|
|
detail::MemoryFolder& folder = *findFolder(path.getParent(), true);
|
|
const std::string_view filename = path.getName();
|
|
|
|
if (folder.folders.contains(filename))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!overwrite && folder.files.contains(filename))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (copyData)
|
|
{
|
|
data = fileData_.emplace_back(data.begin(), data.end());
|
|
}
|
|
|
|
folder.files.emplace(filename, detail::MemoryFile{.data = data});
|
|
return true;
|
|
}
|
|
|
|
void MemoryFileSystemAdapter::addFolder(PathView path)
|
|
{
|
|
(void) findFolder(path, true);
|
|
}
|
|
|
|
detail::MemoryFolder* MemoryFileSystemAdapter::findFolder(PathView path, bool create) MIJIN_NOEXCEPT
|
|
{
|
|
detail::MemoryFolder* folder = &root_;
|
|
for (const std::string_view part : path)
|
|
{
|
|
auto it = folder->folders.find(part);
|
|
if (it == folder->folders.end())
|
|
{
|
|
if (!create)
|
|
{
|
|
return nullptr;
|
|
}
|
|
folder = &folder->folders[std::string(part)];
|
|
}
|
|
else
|
|
{
|
|
folder = &it->second;
|
|
}
|
|
}
|
|
return folder;
|
|
}
|
|
|
|
FileInfo MemoryFileSystemAdapter::folderInfo(const detail::MemoryFolder& folder) const MIJIN_NOEXCEPT
|
|
{
|
|
return {
|
|
.size = folder.folders.size() + folder.files.size(),
|
|
.exists = true,
|
|
.isFolder = true
|
|
};
|
|
}
|
|
|
|
FileInfo MemoryFileSystemAdapter::fileInfo(const detail::MemoryFile& file) const MIJIN_NOEXCEPT
|
|
{
|
|
return {
|
|
.size = file.data.size(),
|
|
.exists = true
|
|
};
|
|
}
|
|
}
|