mewin/mijin2
1
0
Fork 0
Code Issues 2 Pull Requests Projects Releases Wiki Activity

First implementation of custom path type.

Browse Source
This commit is contained in:
Patrick 2025-07-11 01:13:23 +02:00
parent cbd4efb0f9
commit 3c7eda53b2
11 changed files with 616 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
SModule
View File

@ -16,6 +16,7 @@ mijin_sources = Split("""
source/mijin/platform/folders.cpp
source/mijin/util/os.cpp
source/mijin/types/name.cpp
source/mijin/types/path.cpp
source/mijin/virtual_filesystem/filesystem.cpp
source/mijin/virtual_filesystem/memory.cpp
source/mijin/virtual_filesystem/stacked.cpp

15
source/mijin/container/vector_map.hpp
View File

@ -251,12 +251,13 @@ public:
return eraseImpl(idx, count);
}
template<std::equality_comparable_with<TKey> T>
[[nodiscard]]
iterator find(const TKey& key) MIJIN_NOEXCEPT
iterator find(const T& keyValue) MIJIN_NOEXCEPT
{
for (std::size_t idx = 0; idx < keys_.size(); ++idx)
{
if (keys_[idx] == key)
if (keys_[idx] == keyValue)
{
return iterator(&keys_[idx], &values_[idx]);
}
@ -264,12 +265,13 @@ public:
return end();
}
template<std::equality_comparable_with<TKey> T>
[[nodiscard]]
const_iterator find(const TKey& key) const MIJIN_NOEXCEPT
const_iterator find(const T& keyValue) const MIJIN_NOEXCEPT
{
for (std::size_t idx = 0; idx < keys_.size(); ++idx)
{
if (keys_[idx] == key)
if (keys_[idx] == keyValue)
{
return const_iterator(&keys_[idx], &values_[idx]);
}
@ -277,10 +279,11 @@ public:
return end();
}
template<std::equality_comparable_with<TKey> T>
[[nodiscard]]
bool contains(const TKey& key) const MIJIN_NOEXCEPT
bool contains(const T& keyValue) const MIJIN_NOEXCEPT
{
return std::ranges::contains(keys_, key);
return std::ranges::contains(keys_, keyValue);
}
private:
iterator eraseImpl(std::ptrdiff_t idx, std::ptrdiff_t count = 1) MIJIN_NOEXCEPT

40
source/mijin/types/path.cpp Normal file
View File

@ -0,0 +1,40 @@
#include "./path.hpp"
#include <filesystem>
namespace fs = std::filesystem;
namespace mijin
{
//
// internal defines
//
//
// internal constants
//
//
// internal types
//
//
// internal variables
//
//
// internal functions
//
//
// public functions
//
NativePath getWorkingDirectory()
{
return fs::current_path().generic_string();
}
} // namespace mijin

436
source/mijin/types/path.hpp
View File

@ -4,55 +4,384 @@
#if !defined(MIJIN_TYPES_PATH_HPP_INCLUDED)
#define MIJIN_TYPES_PATH_HPP_INCLUDED 1
#include "../debug/assert.hpp"
#include "../internal/common.hpp"
#include "../util/traits.hpp"
#include <ranges>
#include <string>
#include <type_traits>
namespace mijin
{
template<typename TChar = char, TChar separator = TChar('/'), typename TTraits = std::char_traits<TChar>, template<typename> typename TAllocator = MIJIN_DEFAULT_ALLOCATOR>
class BasePath
template<typename T>
concept BasePathType = requires(const T& path)
{
typename T::traits_t;
typename T::char_t;
typename T::char_traits_t;
typename T::allocator_t;
typename T::string_t;
typename T::string_view_t;
typename T::size_type;
typename T::difference_type;
typename T::path_view_t;
{ T::SEPARATOR } -> std::convertible_to<typename T::char_t>;
{ path.stringView() } -> std::convertible_to<typename T::string_view_t>;
};
template<typename T>
concept PathType = BasePathType<T> && std::is_same_v<typename T::char_t, char>;
template<typename T>
concept WPathType = BasePathType<T> && std::is_same_v<typename T::char_t, wchar_t>;
template<typename TChar, TChar separator = TChar('/')>
struct DefaultPathTraits
{
using char_t = TChar;
using char_traits_t = std::char_traits<TChar>;
using allocator_t = std::allocator<TChar>;
using string_t = std::basic_string<char_t, char_traits_t, allocator_t>;
using string_view_t = std::basic_string_view<char_t, char_traits_t>;
using size_type = string_view_t::size_type;
using difference_type = string_view_t::difference_type;
static constexpr char_t SEPARATOR = separator;
static constexpr bool isAbsolute(string_view_t path) MIJIN_NOEXCEPT
{
return !path.empty() && path[0] == SEPARATOR;
}
};
template<typename TChar = char, typename TTraits = DefaultPathTraits<TChar>>
class BasePathView;
template<typename TConcrete, typename TChar = char, typename TTraits = DefaultPathTraits<TChar>>
class MixinPath;
namespace impl
{
template<typename TChar, typename TTraits, TChar separator>
class BasePathIterator
{
public:
using string_t = std::basic_string<TChar, TTraits, TAllocator<char>>;
using size_type = string_t::size_type;
using difference_type = string_t::difference_type;
private:
string_t storage_;
std::string_view full_;
std::string_view::iterator pos_;
std::string_view::iterator next_;
BasePathIterator(std::string_view full, std::string_view::iterator pos) MIJIN_NOEXCEPT : full_(full), pos_(pos) {
if (pos != full_.end() && *pos == separator) {
++pos;
}
findNext();
}
public:
BasePath() = default;
BasePath(const BasePath&) = default;
BasePath(BasePath&&) = default;
BasePath(string_t string) MIJIN_NOEXCEPT_IF(std::is_nothrow_move_constructible<string_t>()) : storage_(std::move(string)) {
simplify();
BasePathIterator() MIJIN_NOEXCEPT : pos_(full_.end()), next_(full_.end()) {}
BasePathIterator(const BasePathIterator&) noexcept = default;
BasePathIterator& operator=(const BasePathIterator&) noexcept = default;
bool operator==(const BasePathIterator& other) MIJIN_NOEXCEPT { MIJIN_ASSERT(full_ == other.full_, "Comparing unrelated iterators."); return pos_ == other.pos_; }
bool operator!=(const BasePathIterator& other) MIJIN_NOEXCEPT { MIJIN_ASSERT(full_ == other.full_, "Comparing unrelated iterators."); return pos_ != other.pos_; }
bool operator<(const BasePathIterator& other) MIJIN_NOEXCEPT { MIJIN_ASSERT(full_ == other.full_, "Comparing unrelated iterators."); return pos_ < other.pos_; }
bool operator<=(const BasePathIterator& other) MIJIN_NOEXCEPT { MIJIN_ASSERT(full_ == other.full_, "Comparing unrelated iterators."); return pos_ <= other.pos_; }
bool operator>(const BasePathIterator& other) MIJIN_NOEXCEPT { MIJIN_ASSERT(full_ == other.full_, "Comparing unrelated iterators."); return pos_ > other.pos_; }
bool operator>=(const BasePathIterator& other) MIJIN_NOEXCEPT { MIJIN_ASSERT(full_ == other.full_, "Comparing unrelated iterators."); return pos_ >= other.pos_; }
std::string_view operator*() const MIJIN_NOEXCEPT
{
MIJIN_ASSERT(pos_ != full_.end(), "Dereferencing an invalid iterator.");
return {pos_, next_};
}
BasePath& operator=(const BasePath&) = default;
BasePath& operator=(BasePath&&) = default;
BasePathIterator& operator++() MIJIN_NOEXCEPT
{
MIJIN_ASSERT(pos_ != full_.end(), "Iterating past end.");
if (next_ == full_.end()) {
pos_ = full_.end();
}
else
{
pos_ = std::next(next_);
findNext();
}
return *this;
}
auto operator<=>(const BasePath&) const noexcept = default;
BasePathIterator operator++(int) const MIJIN_NOEXCEPT
{
BasePathIterator copy(*this);
++copy;
return copy;
}
// TODO
// BasePathIterator& operator--() MIJIN_NOEXCEPT
// {
// MIJIN_ASSERT(pos_ != full_.begin(), "Iterating past begin.");
// next_ = std::prev(pos_);
// pos_ = std::find(std::reverse_iterator(next_), std::reverse_iterator(full_.begin()), separator).base();
// }
private:
void findNext()
{
next_ = std::find(pos_, full_.end(), separator);
}
template<typename TConcrete, typename TCharOther, typename TTraitsOther>
friend class ::mijin::MixinPath;
};
}
template<typename TConcrete, typename TChar, typename TTraits>
class MixinPath
{
public:
using traits_t = TTraits;
using char_t = typename traits_t::char_t;
using char_traits_t = typename traits_t::char_traits_t;
using allocator_t = typename traits_t::allocator_t;
using string_t = typename traits_t::string_t;
using string_view_t = typename traits_t::string_view_t;
using size_type = typename traits_t::size_type;
using difference_type = typename traits_t::difference_type;
using path_view_t = BasePathView<TChar, traits_t>;
using iterator = impl::BasePathIterator<char_t, char_traits_t, traits_t::SEPARATOR>;
using const_iterator = iterator;
static constexpr char_t SEPARATOR = traits_t::SEPARATOR;
constexpr bool operator==(string_view_t stringView) const MIJIN_NOEXCEPT { return stringView() == stringView; }
constexpr bool operator==(const TChar* cString) const MIJIN_NOEXCEPT { return stringView() == cString; }
[[nodiscard]]
const string_t& string() const MIJIN_NOEXCEPT
constexpr string_view_t getName() const MIJIN_NOEXCEPT;
[[nodiscard]]
constexpr path_view_t getParent() const MIJIN_NOEXCEPT;
[[nodiscard]]
constexpr string_view_t stringView() const MIJIN_NOEXCEPT
{
return static_cast<const TConcrete*>(this)->stringViewImpl();
}
[[nodiscard]]
constexpr bool empty() const MIJIN_NOEXCEPT { return stringView().empty(); }
[[nodiscard]]
constexpr size_type size() const MIJIN_NOEXCEPT { return stringView().size(); }
[[nodiscard]]
constexpr bool isAbsolute() const MIJIN_NOEXCEPT
{
return traits_t::isAbsolute(stringView());
}
[[nodiscard]]
iterator begin() const MIJIN_NOEXCEPT { return iterator(stringView(), stringView().begin()); }
[[nodiscard]]
iterator end() const MIJIN_NOEXCEPT { return iterator(stringView(), stringView().end()); }
private:
template<typename TConcreteOther, typename TCharOther, typename TTraitsOther>
friend class MixinPath;
};
template<typename TConcreteA, typename TConcreteB, typename TChar, typename TTraits>
constexpr bool operator==(const MixinPath<TConcreteA, TChar, TTraits>& pathA, const MixinPath<TConcreteB, TChar, TTraits>& pathB) MIJIN_NOEXCEPT
{
return pathA.stringView() == pathB.stringView();
}
template<typename TChar = char, typename TTraits = DefaultPathTraits<TChar>>
class BasePath : public MixinPath<BasePath<TChar, TTraits>, TChar, TTraits>
{
public:
using mixin_t = MixinPath<BasePath<TChar, TTraits>, TChar, TTraits>;
using typename mixin_t::traits_t;
using typename mixin_t::char_t;
using typename mixin_t::char_traits_t;
using typename mixin_t::allocator_t;
using typename mixin_t::string_t;
using typename mixin_t::string_view_t;
using typename mixin_t::difference_type;
using typename mixin_t::path_view_t;
static constexpr char_t SEPARATOR = mixin_t::SEPARATOR;
private:
struct NoSimplify {};
string_t storage_;
constexpr BasePath(string_t storage, NoSimplify) MIJIN_NOEXCEPT_IF(std::is_nothrow_move_constructible<string_t>()) : storage_(std::move(storage)) {}
public:
constexpr BasePath() = default;
constexpr BasePath(const BasePath&) = default;
constexpr BasePath(BasePath&&) = default;
constexpr BasePath(string_t string) MIJIN_NOEXCEPT_IF(std::is_nothrow_move_constructible<string_t>()) : storage_(std::move(string)) {
simplify();
}
constexpr BasePath(const char_t* cString, allocator_t allocator = {}) : BasePath(string_t(cString, std::move(allocator))) {}
constexpr BasePath(string_view_t stringView, allocator_t allocator = {}) : BasePath(string_t(stringView, std::move(allocator))) {}
template<typename TConcreteOther> requires (!std::is_same_v<BasePath<TChar, TTraits>, TConcreteOther>)
explicit constexpr BasePath(const MixinPath<TConcreteOther, TChar, TTraits> other, allocator_t allocator = {}) : BasePath(string_t(other.stringView(), std::move(allocator)), NoSimplify()) {}
constexpr BasePath& operator=(const BasePath&) = default;
constexpr BasePath& operator=(BasePath&&) = default;
constexpr auto operator<=>(const BasePath&) const noexcept = default;
using mixin_t::operator==;
template<typename TConcreteOther>
BasePath& operator/=(const MixinPath<TConcreteOther, char_t, traits_t>& other);
BasePath& operator/=(string_view_t more);
template<typename TConcreteOther>
BasePath operator/(const MixinPath<TConcreteOther, char_t, traits_t>& other) const;
BasePath operator/(string_view_t more) const;
[[nodiscard]]
constexpr const string_t& string() const MIJIN_NOEXCEPT
{
return storage_;
}
[[nodiscard]]
constexpr string_view_t stringViewImpl() const MIJIN_NOEXCEPT
{
return storage_;
}
private:
void simplify() MIJIN_NOEXCEPT;
constexpr void simplify() MIJIN_NOEXCEPT;
};
using Path = BasePath<char>;
using WPath = BasePath<wchar_t>;
template<typename TChar, TChar separator, typename TTraits, template<typename> typename TAllocator>
void BasePath<TChar, separator, TTraits, TAllocator>::simplify() MIJIN_NOEXCEPT
using NativePath = Path; // TODO
template<typename TChar, typename TTraits>
class BasePathView : public MixinPath<BasePathView<TChar, TTraits>, TChar, TTraits>
{
public:
using mixin_t = MixinPath<BasePathView<TChar, TTraits>, TChar, TTraits>;
using typename mixin_t::char_t;
using typename mixin_t::string_view_t;
private:
string_view_t view_;
public:
constexpr BasePathView() noexcept = default;
constexpr BasePathView(const BasePathView&) noexcept = default;
explicit constexpr BasePathView(string_view_t view) MIJIN_NOEXCEPT : view_(view) {}
template<typename TIterator>
constexpr BasePathView(const TIterator& begin, const TIterator& end) MIJIN_NOEXCEPT : view_(begin, end) {}
template<typename TConcreteOther> requires (!std::is_same_v<BasePathView<TChar, TTraits>, TConcreteOther>)
constexpr BasePathView(const MixinPath<TConcreteOther>& other) MIJIN_NOEXCEPT : view_(other.stringView()) {}
constexpr BasePathView& operator=(const BasePathView&) noexcept = default;
constexpr auto operator<=>(const BasePathView&) const noexcept = default;
using mixin_t::operator==;
[[nodiscard]]
constexpr string_view_t stringViewImpl() const MIJIN_NOEXCEPT
{
return view_;
}
};
using PathView = BasePathView<char>;
using WPathView = BasePathView<wchar_t>;
using NativePathView = PathView; // TODO
template<typename TConcrete, typename TChar, typename TTraits>
constexpr auto MixinPath<TConcrete, TChar, TTraits>::getName() const MIJIN_NOEXCEPT -> string_view_t
{
const string_view_t strView = stringView();
auto it = std::ranges::find(std::ranges::reverse_view(strView), SEPARATOR).base();
return {it, strView.end()};
}
template<typename TConcrete, typename TChar, typename TTraits>
constexpr auto MixinPath<TConcrete, TChar, TTraits>::getParent() const MIJIN_NOEXCEPT -> path_view_t
{
const string_view_t strView = stringView();
auto it = std::ranges::find(std::ranges::reverse_view(strView), SEPARATOR).base();
if (it == strView.begin()) {
return {};
}
if (std::prev(it) == strView.begin()) {
return {strView.begin(), it}; // edge case, return "/" instead of nothing
}
return {strView.begin(), std::prev(it)};
}
template<typename TChar, typename TTraits>
template<typename TConcreteOther>
auto BasePath<TChar, TTraits>::operator/=(const MixinPath<TConcreteOther, char_t, traits_t>& other) -> BasePath&
{
if (other.isAbsolute())
{
storage_ = other.stringView();
}
else if (!other.empty())
{
if (other.stringView()[0] != SEPARATOR)
{
storage_.reserve(storage_.size() + other.size() + 1);
storage_.push_back(SEPARATOR);
}
storage_.append_range(other.stringView());
}
return *this;
}
template<typename TChar, typename TTraits>
auto BasePath<TChar, TTraits>::operator/=(string_view_t more) -> BasePath&
{
operator/=(path_view_t(more));
simplify();
return *this;
}
template<typename TChar, typename TTraits>
template<typename TConcreteOther>
auto BasePath<TChar, TTraits>::operator/(const MixinPath<TConcreteOther, char_t, traits_t>& other) const -> BasePath
{
if (other.isAbsolute() || other.empty())
{
return BasePath(string_t(other.stringView(), storage_.get_allocator()), NoSimplify());
}
const bool addSeparator = other.stringView()[0] != SEPARATOR;
string_t combined(storage_.get_allocator());
combined.reserve(storage_.size() + other.stringView().size() + (addSeparator ? 1 : 0));
combined.append_range(storage_);
if (addSeparator) {
combined.push_back(SEPARATOR);
}
combined.append_range(other.stringView());
return BasePath(std::move(combined), NoSimplify());
}
template<typename TChar, typename TTraits>
auto BasePath<TChar, TTraits>::operator/(string_view_t other) const -> BasePath
{
BasePath combined = (*this / path_view_t(other));
combined.simplify();
return combined;
}
template<typename TChar, typename TTraits>
constexpr void BasePath<TChar, TTraits>::simplify() MIJIN_NOEXCEPT
{
// step 1: remove double slashes
difference_type moveBy = 0;
for (auto it = std::next(storage_.begin()); it < storage_.end(); ++it)
{
const bool doubleSlash = (*it == separator && *std::prev(it) == separator); // check this before moving the current character, as that might create a double slash itself
const bool doubleSlash = (*it == SEPARATOR && *std::prev(it) == SEPARATOR); // check this before moving the current character, as that might create a double slash itself
if (moveBy > 0) {
*std::prev(it, moveBy) = *it;
}
@ -61,7 +390,7 @@ void BasePath<TChar, separator, TTraits, TAllocator>::simplify() MIJIN_NOEXCEPT
}
}
// step 1.5: remove trailing slash (but only if it's not the only remaining char)
if (moveBy < static_cast<difference_type>(storage_.size() - 1) && storage_[storage_.size() - moveBy - 1] == separator) {
if (moveBy < static_cast<difference_type>(storage_.size() - 1) && storage_[storage_.size() - moveBy - 1] == SEPARATOR) {
++moveBy;
}
storage_.resize(storage_.size() - moveBy);
@ -74,8 +403,8 @@ void BasePath<TChar, separator, TTraits, TAllocator>::simplify() MIJIN_NOEXCEPT
{
*std::prev(it, moveBy) = *it;
}
if (*std::prev(it, moveBy) == TChar('.') && *std::prev(it, moveBy + 1) == TChar('.') && *std::prev(it, moveBy + 2) == separator
&& (std::next(it) == storage_.end() || *std::next(it) == separator))
if (*std::prev(it, moveBy) == TChar('.') && *std::prev(it, moveBy + 1) == TChar('.') && *std::prev(it, moveBy + 2) == SEPARATOR
&& (std::next(it) == storage_.end() || *std::next(it) == SEPARATOR))
{
if (std::prev(it, moveBy + 2) == storage_.begin())
{
@ -86,7 +415,7 @@ void BasePath<TChar, separator, TTraits, TAllocator>::simplify() MIJIN_NOEXCEPT
// find the start of the preceeding segment
for (auto itStart = std::prev(it, moveBy + 3);; --itStart)
{
if (*std::prev(itStart) == separator || std::prev(itStart) == storage_.begin())
if (*std::prev(itStart) == SEPARATOR || std::prev(itStart) == storage_.begin())
{
// /path/with/../double/dot
// itStart --A A
@ -110,8 +439,8 @@ void BasePath<TChar, separator, TTraits, TAllocator>::simplify() MIJIN_NOEXCEPT
const bool atStart = (it == storage_.begin());
const bool atEnd = (std::next(it) == storage_.end());
const bool emptyEle = (*it == TChar('.') // char is a dot
&& (atStart || *std::prev(it, moveBy + 1) == separator) // previous is a slash or doesn't exist
&& (atEnd || *std::next(it) == separator)); // next is a slash or doesn't exist
&& (atStart || *std::prev(it, moveBy + 1) == SEPARATOR) // previous is a slash or doesn't exist
&& (atEnd || *std::next(it) == SEPARATOR)); // next is a slash or doesn't exist
if (moveBy > 0) {
*std::prev(it, moveBy) = *it;
}
@ -124,6 +453,59 @@ void BasePath<TChar, separator, TTraits, TAllocator>::simplify() MIJIN_NOEXCEPT
}
storage_.resize(storage_.size() - moveBy);
}
} // namespace shiken
template<typename TChar, TChar separator = TChar('/'), typename TTraits = std::char_traits<TChar>>
constexpr bool verifyPathString(std::basic_string_view<TChar, TTraits> stringView) MIJIN_NOEXCEPT
{
for (auto it = std::next(stringView.begin()); it < stringView.end(); ++it)
{
if(*it == separator && *std::prev(it) == separator) {
return false; // double slash
}
if (it != std::next(stringView.begin())
&& *it == TChar('.') && *std::prev(it) == TChar('.') && *std::prev(it, 2) == separator
&& (std::next(it) == stringView.end() || *std::next(it) == separator)) {
return false; // "/.."
}
const bool atStart = (it == stringView.begin());
const bool atEnd = (std::next(it) == stringView.end());
if(*it == TChar('.') // char is a dot
&& (atStart || *std::prev(it) == separator) // previous is a slash or doesn't exist
&& (atEnd || *std::next(it) == separator)) // next is a slash or doesn't exist
{
return false; // "/."
}
}
return true;
}
consteval PathView operator""_pv(const char* cString, std::size_t len)
{
if (!verifyPathString(std::string_view(cString, len))) {
throw "Invalid path string.";
}
return PathView(std::string_view(cString, len));
}
consteval WPathView operator""_pv(const wchar_t* cString, std::size_t len)
{
if (!verifyPathString(std::wstring_view(cString, len))) {
throw "Invalid path string.";
}
return WPathView(std::wstring_view(cString, len));
}
[[nodiscard]]
NativePath getWorkingDirectory();
} // namespace mijin
template<mijin::BasePathType TPath>
struct std::hash<TPath>
{
std::size_t operator()(const TPath& path) const MIJIN_NOEXCEPT
{
return std::hash<std::string_view>()(path.stringView());
}
};
#endif // !defined(MIJIN_TYPES_PATH_HPP_INCLUDED)

127
source/mijin/virtual_filesystem/filesystem.cpp
View File

@ -3,6 +3,10 @@
#include "../platform/folders.hpp"
#include <filesystem>
namespace fs = std::filesystem;
namespace mijin
{
@ -26,100 +30,91 @@ namespace mijin
// internal functions
//
namespace
{
void doGetFileInfo(const fs::path& stlPath, FileInfo& outInfo)
{
std::error_code err;
outInfo.isFolder = fs::is_directory(stlPath, err);
outInfo.isSymlink = fs::is_symlink(stlPath, err);
outInfo.isSpecial = !outInfo.isFolder && !fs::is_regular_file(stlPath, err);
outInfo.isHidden = stlPath.c_str()[0] == '.'; // at least for Linux
if (outInfo.isFolder)
{
const fs::directory_iterator dirIt(stlPath, err);
if (err != std::error_code{})
{
outInfo.size = std::distance(dirIt, fs::directory_iterator());
}
else
{
outInfo.size = 0;
}
}
else if (!outInfo.isSpecial)
{
outInfo.size = fs::file_size(stlPath, err);
if (err)
{
outInfo.size = 0;
}
}
}
}
//
// public functions
//
fs::path OSFileSystemAdapter::getHomeFolder()
std::vector<FolderEntry> OSFileSystemAdapter::listFiles(PathView folder)
{
return getKnownFolder(KnownFolder::USER_HOME);
}
std::vector<FileInfo> OSFileSystemAdapter::listFiles(const fs::path& folder)
{
std::vector<FileInfo> entries;
std::vector<FolderEntry> entries;
std::error_code err;
const fs::directory_iterator iterator(folder, fs::directory_options::skip_permission_denied, err);
const fs::path stlFolder(folder.stringView());
const fs::directory_iterator iterator(stlFolder, fs::directory_options::skip_permission_denied, err);
if (err) {
return {}; // TODO: propagate?
}
for (const fs::directory_entry& entry : iterator)
for (const fs::directory_entry& stlEntry : iterator)
{
FileInfo& info = entries.emplace_back();
info.path = entry.path();
info.exists = true;
info.isFolder = entry.is_directory(err);
info.isSymlink = entry.is_symlink(err);
info.isSpecial = !info.isFolder && !entry.is_regular_file(err);
info.isHidden = info.path.filename().string().starts_with('.'); // at least for Linux
if (info.isFolder)
{
std::error_code errorCode;
fs::directory_iterator dirIt(info.path, errorCode);
if (errorCode != std::error_code{})
{
info.size = std::distance(dirIt, fs::directory_iterator());
}
else
{
info.size = 0;
}
}
else if (!info.isSpecial)
{
info.size = entry.file_size(err);
if (err)
{
info.size = 0;
}
}
FolderEntry& entry = entries.emplace_back();
entry.path = stlEntry.path().generic_string();
entry.info.exists = true;
doGetFileInfo(stlEntry.path(), entry.info);
}
return entries;
}
FileInfo OSFileSystemAdapter::getFileInfo(const fs::path& file)
FileInfo OSFileSystemAdapter::getFileInfo(PathView file)
{
const fs::path stlFile(file.stringView());
FileInfo info = {};
std::error_code err;
info.path = file;
info.exists = fs::exists(file, err);
info.exists = fs::exists(stlFile, err);
if (info.exists)
{
info.isFolder = fs::is_directory(file, err);
info.isSymlink = fs::is_symlink(file, err);
info.isSpecial = !info.isFolder && !fs::is_regular_file(file, err);
info.isHidden = info.path.filename().string().starts_with('.'); // at least for Linux
if (info.isFolder) {
MIJIN_TRY
{
info.size = std::distance(fs::directory_iterator(info.path), fs::directory_iterator());
}
MIJIN_CATCH(std::runtime_error&)
{
info.size = 0;
}
}
else if (!info.isSpecial)
{
info.size = fs::file_size(file, err);
if (err) {
info.size = 0;
}
}
doGetFileInfo(fs::path(file.stringView()), info);
}
return info;
}
Optional<fs::path> OSFileSystemAdapter::getNativePath(const fs::path& file)
Optional<NativePath> OSFileSystemAdapter::getNativePath(PathView file)
{
return file;
return NativePath(file);
}
StreamError OSFileSystemAdapter::open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
StreamError OSFileSystemAdapter::open(PathView path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
{
const std::string pathStr = path.string();
const PathView::string_view_t pathSv = path.stringView();
char* pathStr = static_cast<char*>(alloca(pathSv.size() + 1));
std::memcpy(pathStr, pathSv.data(), pathSv.size());
pathStr[pathSv.size()] = '\0';
auto stream = std::make_unique<FileStream>();
const StreamError error = stream->open(pathStr.c_str(), mode);
const StreamError error = stream->open(pathStr, mode);
if (error != StreamError::SUCCESS) {
return error;
}

48
source/mijin/virtual_filesystem/filesystem.hpp
View File

@ -6,17 +6,15 @@
#include <array>
#include <cmath>
#include <filesystem>
#include <sstream>
#include <string>
#include <vector>
#include "../container/optional.hpp"
#include "../io/stream.hpp"
#include "../internal/common.hpp"
#include "../types/path.hpp"
#include "../util/hash.hpp"
namespace fs = std::filesystem;
namespace mijin
{
@ -34,7 +32,6 @@ namespace mijin
struct FileInfo
{
fs::path path;
/// either file size in bytes, or number of entries if folder
std::size_t size = 0;
bool exists : 1 = false;
@ -44,17 +41,23 @@ struct FileInfo
bool isHidden : 1 = false;
};
struct FolderEntry
{
Path path;
FileInfo info;
};
// basically just a thin wrapper around adapter + path, for utility
class PathReference
{
private:
class FileSystemAdapter* adapter_ = nullptr;
fs::path path_ = {};
Path path_ = {};
public:
PathReference() = default;
PathReference(const PathReference&) = default;
PathReference(PathReference&&) = default;
PathReference(class FileSystemAdapter* adapter, fs::path path) MIJIN_NOEXCEPT : adapter_(adapter), path_(std::move(path)) {}
PathReference(class FileSystemAdapter* adapter, Path path) MIJIN_NOEXCEPT : adapter_(adapter), path_(std::move(path)) {}
PathReference& operator=(const PathReference&) = default;
PathReference& operator=(PathReference&&) MIJIN_NOEXCEPT = default;
@ -63,13 +66,13 @@ public:
[[nodiscard]] bool empty() const MIJIN_NOEXCEPT { return adapter_ == nullptr; }
[[nodiscard]] class FileSystemAdapter* getAdapter() const noexcept { return adapter_; }
[[nodiscard]] const fs::path& getPath() const MIJIN_NOEXCEPT { return path_; }
[[nodiscard]] const Path& getPath() const MIJIN_NOEXCEPT { return path_; }
[[nodiscard]] inline FileInfo getInfo() const;
[[nodiscard]] inline Optional<fs::path> getNativePath() const;
[[nodiscard]] inline Optional<NativePath> getNativePath() const;
[[nodiscard]] inline StreamError open(FileOpenMode mode, std::unique_ptr<Stream>& outStream) const;
[[nodiscard]]
PathReference operator/(const fs::path& more) const
PathReference operator/(const Path& more) const
{
return PathReference(adapter_, path_ / more);
}
@ -80,16 +83,14 @@ class FileSystemAdapter
public:
virtual ~FileSystemAdapter() = default;
[[deprecated("Will be removed ASAP")]]
[[nodiscard]] virtual fs::path getHomeFolder() { return {}; } // TODO: get rid of this ...
[[nodiscard]] virtual std::vector<FileInfo> listFiles(const fs::path& folder) = 0;
[[nodiscard]] virtual FileInfo getFileInfo(const fs::path& file) = 0;
[[nodiscard]] virtual Optional<fs::path> getNativePath(const fs::path& /* file */) { return NULL_OPTIONAL; }
[[nodiscard]] virtual StreamError open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream) = 0;
virtual void getAllPaths(const fs::path& path, std::vector<PathReference>& outPaths) { outPaths.push_back(getPath(path)); }
[[nodiscard]] virtual std::vector<FolderEntry> listFiles(PathView folder) = 0;
[[nodiscard]] virtual FileInfo getFileInfo(PathView file) = 0;
[[nodiscard]] virtual Optional<NativePath> getNativePath(PathView /* file */) { return NULL_OPTIONAL; }
[[nodiscard]] virtual StreamError open(PathView path, FileOpenMode mode, std::unique_ptr<Stream>& outStream) = 0;
virtual void getAllPaths(PathView path, std::vector<PathReference>& outPaths) { outPaths.push_back(getPath(Path(path))); }
[[nodiscard]] PathReference getPath(fs::path path) MIJIN_NOEXCEPT { return PathReference(this, std::move(path)); }
[[nodiscard]] std::vector<PathReference> getAllPaths(const fs::path& path)
[[nodiscard]] PathReference getPath(Path path) MIJIN_NOEXCEPT { return PathReference(this, std::move(path)); }
[[nodiscard]] std::vector<PathReference> getAllPaths(PathView path)
{
std::vector<PathReference> paths;
getAllPaths(path, paths);
@ -100,11 +101,10 @@ public:
class OSFileSystemAdapter : public FileSystemAdapter
{
public:
fs::path getHomeFolder() override;
std::vector<FileInfo> listFiles(const fs::path& folder) override;
FileInfo getFileInfo(const fs::path& file) override;
Optional<fs::path> getNativePath(const fs::path& file) override;
StreamError open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream) override;
std::vector<FolderEntry> listFiles(PathView folder) override;
FileInfo getFileInfo(PathView file) override;
Optional<NativePath> getNativePath(PathView file) override;
StreamError open(PathView, FileOpenMode mode, std::unique_ptr<Stream>& outStream) override;
static OSFileSystemAdapter& getInstance();
};
@ -118,7 +118,7 @@ inline FileInfo PathReference::getInfo() const
return adapter_->getFileInfo(path_);
}
Optional<fs::path> PathReference::getNativePath() const
Optional<NativePath> PathReference::getNativePath() const
{
return adapter_->getNativePath(path_);
}

50
source/mijin/virtual_filesystem/memory.cpp
View File

@ -5,30 +5,31 @@
namespace mijin
{
std::vector<FileInfo> MemoryFileSystemAdapter::listFiles(const fs::path& folder)
std::vector<FolderEntry> MemoryFileSystemAdapter::listFiles(PathView folder)
{
const detail::MemoryFolder* folderObj = findFolder(folder);
if (folderObj == nullptr)
{
return {};
}
std::vector<FileInfo> result;
std::vector<FolderEntry> result;
result.reserve(folderObj->folders.size() + folderObj->files.size());
const Path folderPath(folder);
for (const auto& [name, subFolder] : folderObj->folders)
{
result.push_back(folderInfo(folder / name, subFolder));
result.emplace_back(folderPath / name, folderInfo(subFolder));
}
for (const auto& [name, file] : folderObj->files)
{
result.push_back(fileInfo(folder / name, file));
result.emplace_back(folderPath / name, fileInfo(file));
}
return result;
}
FileInfo MemoryFileSystemAdapter::getFileInfo(const fs::path& file)
FileInfo MemoryFileSystemAdapter::getFileInfo(PathView file)
{
#if 0 // shouldn't be necessary
// empty means root
@ -43,38 +44,38 @@ FileInfo MemoryFileSystemAdapter::getFileInfo(const fs::path& file)
}
#endif
const detail::MemoryFolder* folderObj = findFolder(file.parent_path());
const detail::MemoryFolder* folderObj = findFolder(file.getParent());
if (folderObj == nullptr)
{
return {};
}
const std::string filename = file.filename().generic_string();
const std::string_view filename = file.getName();
if (auto itFolder = folderObj->folders.find(filename); itFolder != folderObj->folders.end())
{
return folderInfo(file, itFolder->second);
return folderInfo(itFolder->second);
}
if (auto itFile = folderObj->files.find(filename); itFile != folderObj->files.end())
{
return fileInfo(file, itFile->second);
return fileInfo(itFile->second);
}
return {};
}
StreamError MemoryFileSystemAdapter::open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
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.parent_path());
const detail::MemoryFolder* folderObj = findFolder(path.getParent());
if (folderObj == nullptr)
{
return StreamError::IO_ERROR;
}
auto itFile = folderObj->files.find(path.filename().generic_string());
auto itFile = folderObj->files.find(path.getName());
if (itFile == folderObj->files.end())
{
return StreamError::IO_ERROR;
@ -87,10 +88,10 @@ StreamError MemoryFileSystemAdapter::open(const fs::path& path, FileOpenMode mod
return StreamError::SUCCESS;
}
bool MemoryFileSystemAdapter::addFile(const fs::path& path, std::span<const std::uint8_t> data, Overwrite overwrite, CopyData copyData)
bool MemoryFileSystemAdapter::addFile(PathView path, std::span<const std::uint8_t> data, Overwrite overwrite, CopyData copyData)
{
detail::MemoryFolder& folder = *findFolder(path.parent_path(), true);
std::string filename = path.filename().generic_string();
detail::MemoryFolder& folder = *findFolder(path.getParent(), true);
const std::string_view filename = path.getName();
if (folder.folders.contains(filename))
{
@ -107,29 +108,28 @@ bool MemoryFileSystemAdapter::addFile(const fs::path& path, std::span<const std:
data = fileData_.emplace_back(data.begin(), data.end());
}
folder.files.emplace(std::move(filename), detail::MemoryFile{.data = data});
folder.files.emplace(filename, detail::MemoryFile{.data = data});
return true;
}
void MemoryFileSystemAdapter::addFolder(const fs::path& path)
void MemoryFileSystemAdapter::addFolder(PathView path)
{
(void) findFolder(path, true);
}
detail::MemoryFolder* MemoryFileSystemAdapter::findFolder(const fs::path& path, bool create) MIJIN_NOEXCEPT
detail::MemoryFolder* MemoryFileSystemAdapter::findFolder(PathView path, bool create) MIJIN_NOEXCEPT
{
detail::MemoryFolder* folder = &root_;
for (const fs::path& part : path)
for (const std::string_view part : path)
{
std::string partname = part.generic_string();
auto it = folder->folders.find(partname);
auto it = folder->folders.find(part);
if (it == folder->folders.end())
{
if (!create)
{
return nullptr;
}
folder = &folder->folders[std::move(partname)];
folder = &folder->folders[std::string(part)];
}
else
{
@ -139,20 +139,18 @@ detail::MemoryFolder* MemoryFileSystemAdapter::findFolder(const fs::path& path,
return folder;
}
FileInfo MemoryFileSystemAdapter::folderInfo(const fs::path& path, const detail::MemoryFolder& folder) const MIJIN_NOEXCEPT
FileInfo MemoryFileSystemAdapter::folderInfo(const detail::MemoryFolder& folder) const MIJIN_NOEXCEPT
{
return {
.path = path,
.size = folder.folders.size() + folder.files.size(),
.exists = true,
.isFolder = true
};
}
FileInfo MemoryFileSystemAdapter::fileInfo(const fs::path& path, const detail::MemoryFile& file) const MIJIN_NOEXCEPT
FileInfo MemoryFileSystemAdapter::fileInfo(const detail::MemoryFile& file) const MIJIN_NOEXCEPT
{
return {
.path = path,
.size = file.data.size(),
.exists = true
};

18
source/mijin/virtual_filesystem/memory.hpp
View File

@ -35,20 +35,20 @@ private:
detail::MemoryFolder root_;
std::vector<std::vector<std::uint8_t>> fileData_;
public:
[[nodiscard]] std::vector<FileInfo> listFiles(const fs::path& folder) override;
[[nodiscard]] FileInfo getFileInfo(const fs::path& file) override;
[[nodiscard]] StreamError open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream) override;
[[nodiscard]] std::vector<FolderEntry> listFiles(PathView folder) override;
[[nodiscard]] FileInfo getFileInfo(PathView file) override;
[[nodiscard]] StreamError open(PathView path, FileOpenMode mode, std::unique_ptr<Stream>& outStream) override;
bool addFile(const fs::path& path, std::span<const std::uint8_t> data, Overwrite overwrite = Overwrite::NO, CopyData copyData = CopyData::NO);
bool addFile(const fs::path& path, std::span<const std::uint8_t> data, CopyData copyData)
bool addFile(PathView path, std::span<const std::uint8_t> data, Overwrite overwrite = Overwrite::NO, CopyData copyData = CopyData::NO);
bool addFile(PathView path, std::span<const std::uint8_t> data, CopyData copyData)
{
return addFile(path, data, Overwrite::NO, copyData);
}
void addFolder(const fs::path& path);
void addFolder(PathView path);
private:
detail::MemoryFolder* findFolder(const fs::path& path, bool create = false) MIJIN_NOEXCEPT;
FileInfo folderInfo(const fs::path& path, const detail::MemoryFolder& folder) const MIJIN_NOEXCEPT;
FileInfo fileInfo(const fs::path& path, const detail::MemoryFile& file) const MIJIN_NOEXCEPT;
detail::MemoryFolder* findFolder(PathView path, bool create = false) MIJIN_NOEXCEPT;
FileInfo folderInfo(const detail::MemoryFolder& folder) const MIJIN_NOEXCEPT;
FileInfo fileInfo(const detail::MemoryFile& file) const MIJIN_NOEXCEPT;
};
} // namespace mijin

54
source/mijin/virtual_filesystem/relative.hpp
View File

@ -27,10 +27,10 @@ class RelativeFileSystemAdapter : public FileSystemAdapter
{
private:
TWrapped wrapped_;
fs::path root_;
Path root_;
public:
template<typename... TArgs>
explicit RelativeFileSystemAdapter(fs::path root, TArgs&&... args)
explicit RelativeFileSystemAdapter(Path root, TArgs&&... args)
: wrapped_(std::forward<TArgs>(args)...), root_(std::move(root)) {}
RelativeFileSystemAdapter(const RelativeFileSystemAdapter&) = default;
RelativeFileSystemAdapter(RelativeFileSystemAdapter&&) MIJIN_NOEXCEPT = default;
@ -38,13 +38,12 @@ public:
RelativeFileSystemAdapter& operator=(const RelativeFileSystemAdapter&) = default;
RelativeFileSystemAdapter& operator=(RelativeFileSystemAdapter&&) MIJIN_NOEXCEPT = default;
fs::path getHomeFolder() override;
std::vector<FileInfo> listFiles(const fs::path& folder) override;
FileInfo getFileInfo(const fs::path& file) override;
Optional<fs::path> getNativePath(const fs::path& file) override;
StreamError open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream) override;
std::vector<FolderEntry> listFiles(PathView folder) override;
FileInfo getFileInfo(PathView file) override;
Optional<NativePath> getNativePath(PathView file) override;
StreamError open(PathView path, FileOpenMode mode, std::unique_ptr<Stream>& outStream) override;
private:
fs::path appendPath(const fs::path& other) const MIJIN_NOEXCEPT;
Path appendPath(PathView other) const MIJIN_NOEXCEPT;
};
//
@ -52,51 +51,44 @@ private:
//
template<typename TWrapped>
fs::path RelativeFileSystemAdapter<TWrapped>::getHomeFolder()
std::vector<FolderEntry> RelativeFileSystemAdapter<TWrapped>::listFiles(PathView folder)
{
return root_;
}
template<typename TWrapped>
std::vector<FileInfo> RelativeFileSystemAdapter<TWrapped>::listFiles(const fs::path& folder)
{
std::vector<FileInfo> result;
std::vector<FolderEntry> result;
result = wrapped_.listFiles(appendPath(folder));
for (FileInfo& fileInfo : result) {
fileInfo.path = "/" / fileInfo.path.lexically_relative(root_);
for (FolderEntry& fileInfo : result) {
fileInfo.path = Path("/") / fileInfo.path.stringView().substr(root_.size());
}
return result;
}
template<typename TWrapped>
FileInfo RelativeFileSystemAdapter<TWrapped>::getFileInfo(const fs::path& file)
FileInfo RelativeFileSystemAdapter<TWrapped>::getFileInfo(PathView file)
{
return wrapped_.getFileInfo(appendPath(file));
}
template<typename TWrapped>
Optional<fs::path> RelativeFileSystemAdapter<TWrapped>::getNativePath(const fs::path& file)
Optional<NativePath> RelativeFileSystemAdapter<TWrapped>::getNativePath(PathView file)
{
return wrapped_.getNativePath(appendPath(file));
}
template<typename TWrapped>
StreamError RelativeFileSystemAdapter<TWrapped>::open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
StreamError RelativeFileSystemAdapter<TWrapped>::open(PathView path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
{
return wrapped_.open(appendPath(path), mode, outStream);
}
template<typename TWrapped>
fs::path RelativeFileSystemAdapter<TWrapped>::appendPath(const fs::path& other) const MIJIN_NOEXCEPT
Path RelativeFileSystemAdapter<TWrapped>::appendPath(PathView other) const MIJIN_NOEXCEPT
{
fs::path combinedPath = root_;
if (other.is_absolute()) {
combinedPath += other;
}
else {
combinedPath /= other;
Path combinedPath = root_;
std::string_view otherSv(other.stringView());
if (!otherSv.empty() && otherSv[0] == Path::SEPARATOR) {
otherSv = otherSv.substr(1);
}
combinedPath /= otherSv;
return combinedPath;
}
@ -105,7 +97,7 @@ namespace vfs_pipe
template<typename TBase>
struct RelativeBuilder : Builder<RelativeBuilder<TBase>, RelativeFileSystemAdapter<typename TBase::adapter_t>>
{
fs::path root;
Path root;
TBase base;
std::unique_ptr<RelativeFileSystemAdapter<typename TBase::adapter_t>> build()
@ -116,11 +108,11 @@ struct RelativeBuilder : Builder<RelativeBuilder<TBase>, RelativeFileSystemAdapt
struct RelativeOptions
{
fs::path root;
Path root;
};
[[nodiscard]]
inline RelativeOptions relative_to(fs::path root) noexcept
inline RelativeOptions relative_to(Path root) noexcept
{
return {.root = std::move(root) };
}

42
source/mijin/virtual_filesystem/stacked.cpp
View File

@ -31,40 +31,20 @@ namespace mijin
// public functions
//
fs::path StackedFileSystemAdapter::getHomeFolder()
std::vector<FolderEntry> StackedFileSystemAdapter::listFiles(PathView folder)
{
if (adapters_.empty()) {
return fs::path();
}
#if MIJIN_COMPILER == MIJIN_COMPILER_MSVC
#pragma warning(push)
#pragma warning(disable : 4996) // yeah, we're using a deprecated function here, in order to implement another deprecated function ¯\_(ツ)_/¯
#elif MIJIN_COMPILER == MIJIN_COMPILER_GCC || MIJIN_COMPILER == MIJIN_COMPILER_CLANG
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
return adapters_.front()->getHomeFolder();
#if MIJIN_COMPILER == MIJIN_COMPILER_MSVC
#pragma warning(pop)
#elif MIJIN_COMPILER == MIJIN_COMPILER_GCC || MIJIN_COMPILER == MIJIN_COMPILER_CLANG
#pragma GCC diagnostic pop
#endif
}
std::vector<FileInfo> StackedFileSystemAdapter::listFiles(const fs::path& folder)
{
std::vector<FileInfo> files;
std::vector<FolderEntry> files;
for (auto& adapter : adapters_)
{
for (const FileInfo& file : adapter->listFiles(folder))
for (const FolderEntry& entry : adapter->listFiles(folder))
{
auto it = std::find_if(files.begin(), files.end(), [&](const FileInfo& existing)
auto it = std::ranges::find_if(files, [&](const FolderEntry& existing)
{
return existing.path == file.path;
return existing.path == entry.path;
});
if (it == files.end()) {
files.push_back(file);
files.push_back(entry);
}
}
}
@ -72,7 +52,7 @@ std::vector<FileInfo> StackedFileSystemAdapter::listFiles(const fs::path& folder
return files;
}
FileInfo StackedFileSystemAdapter::getFileInfo(const fs::path& file)
FileInfo StackedFileSystemAdapter::getFileInfo(PathView file)
{
for (auto& adapter : adapters_)
{
@ -85,11 +65,11 @@ FileInfo StackedFileSystemAdapter::getFileInfo(const fs::path& file)
return {};
}
Optional<fs::path> StackedFileSystemAdapter::getNativePath(const fs::path& file)
Optional<NativePath> StackedFileSystemAdapter::getNativePath(PathView file)
{
for (auto& adapter : adapters_)
{
Optional<fs::path> result = adapter->getNativePath(file);
Optional<NativePath> result = adapter->getNativePath(file);
if (!result.empty())
{
return result;
@ -98,7 +78,7 @@ Optional<fs::path> StackedFileSystemAdapter::getNativePath(const fs::path& file)
return NULL_OPTIONAL;
}
StreamError StackedFileSystemAdapter::open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
StreamError StackedFileSystemAdapter::open(PathView path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
{
// try to open existing files first
for (auto& adapter : adapters_)
@ -125,7 +105,7 @@ StreamError StackedFileSystemAdapter::open(const fs::path& path, FileOpenMode mo
return StreamError::IO_ERROR;
}
void StackedFileSystemAdapter::getAllPaths(const fs::path& path, std::vector<PathReference>& outPaths)
void StackedFileSystemAdapter::getAllPaths(PathView path, std::vector<PathReference>& outPaths)
{
for (auto& adapter : adapters_)
{

11
source/mijin/virtual_filesystem/stacked.hpp
View File

@ -28,12 +28,11 @@ class StackedFileSystemAdapter : public FileSystemAdapter
private:
std::vector<std::unique_ptr<FileSystemAdapter>> adapters_;
public:
fs::path getHomeFolder() override;
std::vector<FileInfo> listFiles(const fs::path& folder) override;
FileInfo getFileInfo(const fs::path& file) override;
Optional<fs::path> getNativePath(const fs::path& file) override;
StreamError open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream) override;
void getAllPaths(const fs::path &path, std::vector<PathReference> &outPaths) override;
std::vector<FolderEntry> listFiles(PathView folder) override;
FileInfo getFileInfo(PathView file) override;
Optional<NativePath> getNativePath(PathView file) override;
StreamError open(PathView path, FileOpenMode mode, std::unique_ptr<Stream>& outStream) override;
void getAllPaths(PathView path, std::vector<PathReference> &outPaths) override;
using FileSystemAdapter::getAllPaths;
inline FileSystemAdapter* addAdapter(std::unique_ptr<FileSystemAdapter>&& adapter) {