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/platform/folders.cpp
source/mijin/util/os.cpp source/mijin/util/os.cpp
source/mijin/types/name.cpp source/mijin/types/name.cpp
source/mijin/types/path.cpp
source/mijin/virtual_filesystem/filesystem.cpp source/mijin/virtual_filesystem/filesystem.cpp
source/mijin/virtual_filesystem/memory.cpp source/mijin/virtual_filesystem/memory.cpp
source/mijin/virtual_filesystem/stacked.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); return eraseImpl(idx, count);
} }
template<std::equality_comparable_with<TKey> T>
[[nodiscard]] [[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) for (std::size_t idx = 0; idx < keys_.size(); ++idx)
{ {
if (keys_[idx] == key) if (keys_[idx] == keyValue)
{ {
return iterator(&keys_[idx], &values_[idx]); return iterator(&keys_[idx], &values_[idx]);
} }
@ -264,12 +265,13 @@ public:
return end(); return end();
} }
template<std::equality_comparable_with<TKey> T>
[[nodiscard]] [[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) 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]); return const_iterator(&keys_[idx], &values_[idx]);
} }
@ -277,10 +279,11 @@ public:
return end(); return end();
} }
template<std::equality_comparable_with<TKey> T>
[[nodiscard]] [[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: private:
iterator eraseImpl(std::ptrdiff_t idx, std::ptrdiff_t count = 1) MIJIN_NOEXCEPT 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) #if !defined(MIJIN_TYPES_PATH_HPP_INCLUDED)
#define MIJIN_TYPES_PATH_HPP_INCLUDED 1 #define MIJIN_TYPES_PATH_HPP_INCLUDED 1
#include "../debug/assert.hpp"
#include "../internal/common.hpp" #include "../internal/common.hpp"
#include "../util/traits.hpp"
#include <ranges>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
namespace mijin 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: 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: public:
BasePath() = default; BasePathIterator() MIJIN_NOEXCEPT : pos_(full_.end()), next_(full_.end()) {}
BasePath(const BasePath&) = default; BasePathIterator(const BasePathIterator&) noexcept = default;
BasePath(BasePath&&) = default;
BasePath(string_t string) MIJIN_NOEXCEPT_IF(std::is_nothrow_move_constructible<string_t>()) : storage_(std::move(string)) { BasePathIterator& operator=(const BasePathIterator&) noexcept = default;
simplify();
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; BasePathIterator& operator++() MIJIN_NOEXCEPT
BasePath& operator=(BasePath&&) = default; {
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]] [[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_; return storage_;
} }
private: private:
void simplify() MIJIN_NOEXCEPT; constexpr void simplify() MIJIN_NOEXCEPT;
}; };
using Path = BasePath<char>; using Path = BasePath<char>;
using WPath = BasePath<wchar_t>; using WPath = BasePath<wchar_t>;
template<typename TChar, TChar separator, typename TTraits, template<typename> typename TAllocator> using NativePath = Path; // TODO
void BasePath<TChar, separator, TTraits, TAllocator>::simplify() MIJIN_NOEXCEPT
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 // step 1: remove double slashes
difference_type moveBy = 0; difference_type moveBy = 0;
for (auto it = std::next(storage_.begin()); it < storage_.end(); ++it) 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) { if (moveBy > 0) {
*std::prev(it, moveBy) = *it; *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) // 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; ++moveBy;
} }
storage_.resize(storage_.size() - moveBy); storage_.resize(storage_.size() - moveBy);
@ -74,8 +403,8 @@ void BasePath<TChar, separator, TTraits, TAllocator>::simplify() MIJIN_NOEXCEPT
{ {
*std::prev(it, moveBy) = *it; *std::prev(it, moveBy) = *it;
} }
if (*std::prev(it, moveBy) == TChar('.') && *std::prev(it, moveBy + 1) == TChar('.') && *std::prev(it, moveBy + 2) == 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)) && (std::next(it) == storage_.end() || *std::next(it) == SEPARATOR))
{ {
if (std::prev(it, moveBy + 2) == storage_.begin()) 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 // find the start of the preceeding segment
for (auto itStart = std::prev(it, moveBy + 3);; --itStart) 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 // /path/with/../double/dot
// itStart --A A // itStart --A A
@ -110,8 +439,8 @@ void BasePath<TChar, separator, TTraits, TAllocator>::simplify() MIJIN_NOEXCEPT
const bool atStart = (it == storage_.begin()); const bool atStart = (it == storage_.begin());
const bool atEnd = (std::next(it) == storage_.end()); const bool atEnd = (std::next(it) == storage_.end());
const bool emptyEle = (*it == TChar('.') // char is a dot const bool emptyEle = (*it == TChar('.') // char is a dot
&& (atStart || *std::prev(it, moveBy + 1) == separator) // previous 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 && (atEnd || *std::next(it) == SEPARATOR)); // next is a slash or doesn't exist
if (moveBy > 0) { if (moveBy > 0) {
*std::prev(it, moveBy) = *it; *std::prev(it, moveBy) = *it;
} }
@ -124,6 +453,59 @@ void BasePath<TChar, separator, TTraits, TAllocator>::simplify() MIJIN_NOEXCEPT
} }
storage_.resize(storage_.size() - moveBy); 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) #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 "../platform/folders.hpp"
#include <filesystem>
namespace fs = std::filesystem;
namespace mijin namespace mijin
{ {
@ -26,100 +30,91 @@ namespace mijin
// internal functions // 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 // public functions
// //
fs::path OSFileSystemAdapter::getHomeFolder() std::vector<FolderEntry> OSFileSystemAdapter::listFiles(PathView folder)
{ {
return getKnownFolder(KnownFolder::USER_HOME); std::vector<FolderEntry> entries;
}
std::vector<FileInfo> OSFileSystemAdapter::listFiles(const fs::path& folder)
{
std::vector<FileInfo> entries;
std::error_code err; 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) { if (err) {
return {}; // TODO: propagate? return {}; // TODO: propagate?
} }
for (const fs::directory_entry& entry : iterator) for (const fs::directory_entry& stlEntry : iterator)
{ {
FileInfo& info = entries.emplace_back(); FolderEntry& entry = entries.emplace_back();
info.path = entry.path(); entry.path = stlEntry.path().generic_string();
info.exists = true; entry.info.exists = true;
info.isFolder = entry.is_directory(err); doGetFileInfo(stlEntry.path(), entry.info);
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;
}
}
} }
return entries; return entries;
} }
FileInfo OSFileSystemAdapter::getFileInfo(const fs::path& file) FileInfo OSFileSystemAdapter::getFileInfo(PathView file)
{ {
const fs::path stlFile(file.stringView());
FileInfo info = {}; FileInfo info = {};
std::error_code err; std::error_code err;
info.path = file; info.exists = fs::exists(stlFile, err);
info.exists = fs::exists(file, err);
if (info.exists) if (info.exists)
{ {
info.isFolder = fs::is_directory(file, err); doGetFileInfo(fs::path(file.stringView()), info);
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;
}
}
} }
return 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>(); 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) { if (error != StreamError::SUCCESS) {
return error; return error;
} }

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

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

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

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

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

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

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

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

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

@ -31,40 +31,20 @@ namespace mijin
// public functions // public functions
// //
fs::path StackedFileSystemAdapter::getHomeFolder() std::vector<FolderEntry> StackedFileSystemAdapter::listFiles(PathView folder)
{ {
if (adapters_.empty()) { std::vector<FolderEntry> files;
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;
for (auto& adapter : adapters_) 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()) { 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; return files;
} }
FileInfo StackedFileSystemAdapter::getFileInfo(const fs::path& file) FileInfo StackedFileSystemAdapter::getFileInfo(PathView file)
{ {
for (auto& adapter : adapters_) for (auto& adapter : adapters_)
{ {
@ -85,11 +65,11 @@ FileInfo StackedFileSystemAdapter::getFileInfo(const fs::path& file)
return {}; return {};
} }
Optional<fs::path> StackedFileSystemAdapter::getNativePath(const fs::path& file) Optional<NativePath> StackedFileSystemAdapter::getNativePath(PathView file)
{ {
for (auto& adapter : adapters_) for (auto& adapter : adapters_)
{ {
Optional<fs::path> result = adapter->getNativePath(file); Optional<NativePath> result = adapter->getNativePath(file);
if (!result.empty()) if (!result.empty())
{ {
return result; return result;
@ -98,7 +78,7 @@ Optional<fs::path> StackedFileSystemAdapter::getNativePath(const fs::path& file)
return NULL_OPTIONAL; 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 // try to open existing files first
for (auto& adapter : adapters_) for (auto& adapter : adapters_)
@ -125,7 +105,7 @@ StreamError StackedFileSystemAdapter::open(const fs::path& path, FileOpenMode mo
return StreamError::IO_ERROR; 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_) for (auto& adapter : adapters_)
{ {

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

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