Fixed compilation using GCC due to duplicate template parameter name.

Made throwOnError() throw Exception instead of std::runtime_error.

SModule

@@ -16,7 +16,6 @@ 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

source/mijin/async/coroutine.hpp

@@ -5,10 +5,6 @@
 #define MIJIN_ASYNC_COROUTINE_HPP_INCLUDED 1
 
 
-#if !defined(MIJIN_COROUTINE_ENABLE_DEBUG_INFO)
-#   define MIJIN_COROUTINE_ENABLE_DEBUG_INFO 0 // Capture stack each time a coroutine is started. Warning, expensive! // TODO: maybe implement a lighter version only storing the return address?
-#endif
-
 #include <any>
 #include <chrono>
 #include <coroutine>
@@ -25,7 +21,17 @@
 #include "../util/flag.hpp"
 #include "../util/iterators.hpp"
 #include "../util/misc.hpp"
+#include "../util/scope_guard.hpp"
 #include "../util/traits.hpp"
+
+#if !defined(MIJIN_COROUTINE_ENABLE_DEBUG_INFO)
+#   define MIJIN_COROUTINE_ENABLE_DEBUG_INFO 0 // Capture stack each time a coroutine is started. Warning, expensive! // TODO: maybe implement a lighter version only storing the return address?
+#endif
+
+#if !defined(MIJIN_COROUTINE_ENABLE_EXCEPTIONS)
+#   define MIJIN_COROUTINE_ENABLE_EXCEPTIONS 0
+#endif
+
 #if MIJIN_COROUTINE_ENABLE_DEBUG_INFO
 #include "../debug/stacktrace.hpp"
 #endif
@@ -185,10 +191,16 @@ struct TaskReturn<void, TPromise>
 };
 }
 
-template<typename TValue>
+template<typename TValue, template<typename> typename TAllocator = MIJIN_DEFAULT_ALLOCATOR>
+using TaskFuture = Future<TValue, TAllocator, MIJIN_COROUTINE_ENABLE_EXCEPTIONS>;
+
+template<typename TValue, template<typename> typename TAllocator = MIJIN_DEFAULT_ALLOCATOR>
+using TaskFuturePtr = FuturePtr<TValue, TAllocator, MIJIN_COROUTINE_ENABLE_EXCEPTIONS>;
+
+template<typename TValue, template<typename> typename TAllocator>
 struct TaskAwaitableFuture
 {
-    FuturePtr<TValue> future;
+    TaskFuturePtr<TValue, TAllocator> future;
 
     [[nodiscard]] constexpr bool await_ready() const MIJIN_NOEXCEPT { return future->ready(); }
     constexpr void await_suspend(std::coroutine_handle<>) const MIJIN_NOEXCEPT {}
@@ -328,12 +340,12 @@ struct TaskPromise : impl::TaskReturn<typename TTraits::result_t, TaskPromise<TT
 
     // constexpr void unhandled_exception() MIJIN_NOEXCEPT {}
 
-    template<typename TValue>
-    auto await_transform(FuturePtr<TValue> future, std::source_location sourceLoc = std::source_location::current()) MIJIN_NOEXCEPT
+    template<typename TValue, template<typename> typename TAllocator2>
+    auto await_transform(TaskFuturePtr<TValue, TAllocator2> future, std::source_location sourceLoc = std::source_location::current()) MIJIN_NOEXCEPT
     {
         MIJIN_ASSERT(loop_ != nullptr, "Cannot await future outside of a loop!");
         sharedState_->sourceLoc = std::move(sourceLoc);
-        TaskAwaitableFuture<TValue> awaitable{future};
+        TaskAwaitableFuture<TValue, TAllocator> awaitable{future};
         if (!awaitable.await_ready())
         {
             state_.status = TaskStatus::WAITING;
@@ -634,10 +646,10 @@ public:
     void setUncaughtExceptionHandler(exception_handler_t handler) MIJIN_NOEXCEPT { uncaughtExceptionHandler_ = std::move(handler); }
 
     template<typename TResult>
-    FuturePtr<TResult> addTaskImpl(TaskBase<TResult, TAllocator> task, TaskHandle* outHandle) MIJIN_NOEXCEPT;
+    TaskFuturePtr<TResult, TAllocator> addTaskImpl(TaskBase<TResult, TAllocator> task, TaskHandle* outHandle) MIJIN_NOEXCEPT;
 
     template<typename TResult>
-    FuturePtr<TResult> addTask(TaskBase<TResult, TAllocator> task, TaskHandle* outHandle = nullptr) MIJIN_NOEXCEPT
+    TaskFuturePtr<TResult, TAllocator> addTask(TaskBase<TResult, TAllocator> task, TaskHandle* outHandle = nullptr) MIJIN_NOEXCEPT
     {
         static_assert(TaskAllocatorTraits<TAllocator>::default_is_valid_v, "Allocator is not valid when default constructed, use makeTask() instead.");
         return addTaskImpl(std::move(task), outHandle);
@@ -663,7 +675,7 @@ protected:
 protected:
     static inline TaskLoop*& currentLoopStorage() MIJIN_NOEXCEPT;
     template<typename TResult>
-    static inline void setFutureHelper(StoredTask& storedTask) MIJIN_NOEXCEPT;
+    static inline void setFutureHelper(StoredTask& storedTask) MIJIN_NOEXCEPT_IF(!MIJIN_COROUTINE_ENABLE_EXCEPTIONS);
 };
 
 template<typename TResult = void>
@@ -810,12 +822,12 @@ TaskBase<TResult, TAllocator>::~TaskBase() MIJIN_NOEXCEPT
 
 template<template<typename> typename TAllocator>
 template<typename TResult>
-FuturePtr<TResult> TaskLoop<TAllocator>::addTaskImpl(TaskBase<TResult, TAllocator> task, TaskHandle* outHandle) MIJIN_NOEXCEPT
+TaskFuturePtr<TResult, TAllocator> TaskLoop<TAllocator>::addTaskImpl(TaskBase<TResult, TAllocator> task, TaskHandle* outHandle) MIJIN_NOEXCEPT
 {
     MIJIN_ASSERT(!task.getLoop(), "Attempting to add task that already has a loop!");
     task.setLoop(this);
 
-    FuturePtr<TResult> future = std::allocate_shared<Future<TResult>>(TAllocator<Future<TResult>>(allocator_), allocator_);
+    TaskFuturePtr<TResult, TAllocator> future = std::allocate_shared<TaskFuture<TResult, TAllocator>>(TAllocator<Future<TResult, TAllocator>>(allocator_), allocator_);
     auto setFuture = &setFutureHelper<TResult>;
 
     if (outHandle != nullptr)
@@ -854,7 +866,7 @@ TaskStatus TaskLoop<TAllocator>::tickTask(StoredTask& task)
     while (status == TaskStatus::RUNNING);
     impl::gCurrentTaskState = nullptr;
 
-#if MIJIN_COROUTINE_ENABLE_EXCEPTION_HANDLING
+#if MIJIN_COROUTINE_ENABLE_EXCEPTION_HANDLING && !MIJIN_COROUTINE_ENABLE_EXCEPTIONS
     if (task.task && task.task->exception())
     {
         try
@@ -882,7 +894,22 @@ TaskStatus TaskLoop<TAllocator>::tickTask(StoredTask& task)
 #endif // MIJIN_COROUTINE_ENABLE_EXCEPTION_HANDLING
     if (status == TaskStatus::YIELDED || status == TaskStatus::FINISHED)
     {
-        task.setFuture(task);
+        try
+        {
+            task.setFuture(task);
+        }
+        catch(TaskCancelled&) {}
+        catch(...)
+        {
+            if (uncaughtExceptionHandler_)
+            {
+                uncaughtExceptionHandler_(std::current_exception());
+            }
+            else
+            {
+                throw;
+            }
+        }
     }
     return status;
 }
@@ -909,10 +936,22 @@ template<template<typename> typename TAllocator>
 
 template<template<typename> typename TAllocator>
 template<typename TResult>
-/* static */ inline void TaskLoop<TAllocator>::setFutureHelper(StoredTask& storedTask) MIJIN_NOEXCEPT
+/* static */ inline void TaskLoop<TAllocator>::setFutureHelper(StoredTask& storedTask) MIJIN_NOEXCEPT_IF(!MIJIN_COROUTINE_ENABLE_EXCEPTIONS)
 {
     TaskBase<TResult, TAllocator>& task = *static_cast<TaskBase<TResult, TAllocator>*>(storedTask.task->raw());
-    auto future = std::any_cast<FuturePtr<TResult>>(storedTask.resultData);
+    const auto& future = std::any_cast<TaskFuturePtr<TResult, TAllocator>&>(storedTask.resultData);
+#if MIJIN_COROUTINE_ENABLE_EXCEPTIONS
+    if (task.state().exception)
+    {
+        if (future.use_count() < 2)
+        {
+            // future has been discarded, but someone must handle the exception
+            std::rethrow_exception(task.state().exception);
+        }
+        future->setException(task.state().exception);
+        return;
+    }
+#endif
 
     if constexpr (!std::is_same_v<TResult, void>)
     {
@@ -997,6 +1036,9 @@ inline auto BaseSimpleTaskLoop<TAllocator>::tick() -> CanContinue
     // set current taskloop
     MIJIN_ASSERT(TaskLoop<TAllocator>::currentLoopStorage() == nullptr, "Trying to tick a loop from a coroutine, this is not supported.");
     TaskLoop<TAllocator>::currentLoopStorage() = this;
+    MIJIN_SCOPE_EXIT {
+        TaskLoop<TAllocator>::currentLoopStorage() = nullptr;
+    };
     threadId_ = std::this_thread::get_id();
 
     // move over all tasks from newTasks
@@ -1046,8 +1088,6 @@ inline auto BaseSimpleTaskLoop<TAllocator>::tick() -> CanContinue
             canContinue = CanContinue::YES;
         }
     }
-    // reset current loop
-    TaskLoop<TAllocator>::currentLoopStorage() = nullptr;
 
     // remove any tasks that have been transferred to another queue
     it = std::remove_if(tasks_.begin(), tasks_.end(), [](const StoredTask& task) {
@@ -1247,14 +1287,14 @@ inline TaskAwaitableSuspend c_suspend() {
     return TaskAwaitableSuspend();
 }
 
-template<template<typename...> typename TCollection, typename TType, typename... TTemplateArgs>
-Task<> c_allDone(const TCollection<FuturePtr<TType>, TTemplateArgs...>& futures)
+template<template<typename...> typename TCollection, FutureType TFuture, typename... TTemplateArgs>
+Task<> c_allDone(const TCollection<TFuture, TTemplateArgs...>& futures)
 {
     bool allDone = true;
     do
     {
         allDone = true;
-        for (const FuturePtr<TType>& future : futures)
+        for (const TFuture& future : futures)
         {
             if (future && !future->ready()) {
                 allDone = false;

source/mijin/async/future.hpp

@@ -4,6 +4,7 @@
 #if !defined(MIJIN_ASYNC_FUTURE_HPP_INCLUDED)
 #define MIJIN_ASYNC_FUTURE_HPP_INCLUDED 1
 
+#include <exception>
 #include <memory>
 #include <optional>
 #include <tuple>
@@ -27,43 +28,113 @@ namespace mijin
 //
 // public types
 //
-template<typename TValue, template<typename> typename TAllocator = MIJIN_DEFAULT_ALLOCATOR>
+template<typename TValue, template<typename> typename TAllocator = MIJIN_DEFAULT_ALLOCATOR, bool exceptions = false>
 class Future;
 
 // TODO: add support for mutexes and waiting for futures
 namespace impl
 {
-template<typename TValue>
+template<typename TValue, bool exceptions>
 struct FutureStorage
 {
     Optional<TValue> value;
 
+    [[nodiscard]]
+    bool hasValue() const MIJIN_NOEXCEPT
+    {
+        return !value.empty();
+    }
+
     void setValue(TValue value_) MIJIN_NOEXCEPT { value = std::move(value_); }
     [[nodiscard]] TValue& getValue() MIJIN_NOEXCEPT { return value.get(); }
 
 };
 
-// template<typename TValue>
-// struct FutureStorage<TValue&>
-// {
-//     Optional<TValue*> value;
-//
-//     void setValue(TValue& value_) MIJIN_NOEXCEPT { value = &value_; }
-//     [[nodiscard]] TValue& getValue() const MIJIN_NOEXCEPT { return *value.get(); }
-// };
+template<>
+struct FutureStorage<void, false>
+{
+    bool isSet = false;
+
+    [[nodiscard]]
+    bool hasValue() const MIJIN_NOEXCEPT
+    {
+        return isSet;
+    }
+    void setValue() MIJIN_NOEXCEPT
+    {
+        isSet = true;
+    }
+    void getValue() MIJIN_NOEXCEPT {}
+};
+
+#if MIJIN_ENABLE_EXCEPTIONS
+template<typename TValue>
+struct FutureStorage<TValue, true>
+{
+    Optional<TValue> value;
+    std::exception_ptr exception;
+
+    [[nodiscard]]
+    bool hasValue() const MIJIN_NOEXCEPT
+    {
+        if (exception) {
+            return true;
+        }
+        return !value.empty();
+    }
+
+    void setException(std::exception_ptr exc) MIJIN_NOEXCEPT
+    {
+        exception = std::move(exc);
+    }
+    void setValue(TValue value_) MIJIN_NOEXCEPT { value = std::move(value_); }
+    [[nodiscard]] TValue& getValue()
+    {
+        if (exception) {
+            std::rethrow_exception(exception);
+        }
+        return value.get();
+    }
+
+};
 
 template<>
-struct FutureStorage<void>
+struct FutureStorage<void, true>
 {
+    bool isSet = false;
+    std::exception_ptr exception;
+
+    [[nodiscard]]
+    bool hasValue() const MIJIN_NOEXCEPT
+    {
+        if (exception) {
+            return true;
+        }
+        return isSet;
+    }
+    void setException(std::exception_ptr exc) MIJIN_NOEXCEPT
+    {
+        exception = std::move(exc);
+    }
+    void setValue() MIJIN_NOEXCEPT
+    {
+        isSet = true;
+    }
+    void getValue()
+    {
+        if (exception) {
+            std::rethrow_exception(exception);
+        }
+    }
 };
+#endif
 } // namespace impl
 
-template<typename TValue, template<typename> typename TAllocator>
+template<typename TValue, template<typename> typename TAllocator, bool exceptions>
 class Future
 {
 private:
-    [[no_unique_address]] impl::FutureStorage<TValue> value_;
-    bool isSet_ = false;
+    impl::FutureStorage<TValue, exceptions> value_;
 public:
     Future() = default;
     Future(const Future&) = delete;
@@ -80,10 +151,12 @@ public:
     constexpr bool operator!() const MIJIN_NOEXCEPT { return !ready(); }
 public: // access
     [[nodiscard]]
-    constexpr decltype(auto) get() MIJIN_NOEXCEPT
+    constexpr decltype(auto) get() MIJIN_NOEXCEPT_IF(!exceptions)
     {
-        MIJIN_ASSERT(isSet_, "Attempting to get from future that is not ready.");
-        if constexpr(std::is_same_v<TValue, void>) {
+        MIJIN_ASSERT(ready(), "Attempting to get from future that is not ready.");
+        if constexpr(std::is_same_v<TValue, void>)
+        {
+            value_.getValue(); // in case of exceptions
             return;
         }
         else {
@@ -91,10 +164,12 @@ public: // access
         }
     }
     [[nodiscard]]
-    constexpr decltype(auto) get() const MIJIN_NOEXCEPT
+    constexpr decltype(auto) get() const MIJIN_NOEXCEPT_IF(!exceptions)
     {
-        MIJIN_ASSERT(isSet_, "Attempting to get from future that is not ready.");
-        if constexpr(std::is_same_v<TValue, void>) {
+        MIJIN_ASSERT(ready(), "Attempting to get from future that is not ready.");
+        if constexpr(std::is_same_v<TValue, void>)
+        {
+            value_.getValue(); // in case of exceptions
             return;
         }
         else {
@@ -104,22 +179,22 @@ public: // access
     [[nodiscard]]
     constexpr bool ready() const MIJIN_NOEXCEPT
     {
-        return isSet_;
+        return value_.hasValue();
     }
 public: // modification
     template<typename TArg> requires (!std::is_same_v<TValue, void>)
     constexpr void set(TArg&& value) MIJIN_NOEXCEPT
     {
-        MIJIN_ASSERT(!isSet_, "Trying to set a future twice!");
+        MIJIN_ASSERT(!ready(), "Trying to set a future twice!");
         value_.setValue(std::move(value));
-        isSet_ = true;
         sigSet.emit();
     }
     constexpr void set() MIJIN_NOEXCEPT requires (std::is_same_v<TValue, void>)
     {
-        MIJIN_ASSERT(!isSet_, "Trying to set a future twice!");
-        isSet_ = true;
-        if constexpr (std::is_same_v<TValue, void>) {
+        MIJIN_ASSERT(!ready(), "Trying to set a future twice!");
+        if constexpr (std::is_same_v<TValue, void>)
+        {
+            value_.setValue();
             sigSet.emit();
         }
         else {
@@ -127,12 +202,38 @@ public: // modification
             MIJIN_ERROR("Attempting to call set(void) on future with value.");
         }
     }
+    constexpr void setException(std::exception_ptr exception) requires (exceptions)
+    {
+        MIJIN_ASSERT(!ready(), "Trying to set a future twice!");
+        if constexpr (exceptions)
+        {
+            value_.setException(std::move(exception));
+        }
+    }
 public: // signals
     BaseSignal<TAllocator> sigSet;
 };
 
+template<typename TValue = void, template<typename> typename TAllocator = MIJIN_DEFAULT_ALLOCATOR, bool exceptions = false>
+using FuturePtr = std::shared_ptr<Future<TValue, TAllocator, exceptions>>;
+
 template<typename TValue = void, template<typename> typename TAllocator = MIJIN_DEFAULT_ALLOCATOR>
-using FuturePtr = std::shared_ptr<Future<TValue, TAllocator>>;
+using ExceptFuture = Future<TValue, TAllocator, true>;
+
+template<typename TValue = void, template<typename> typename TAllocator = MIJIN_DEFAULT_ALLOCATOR>
+using ExceptFuturePtr = std::shared_ptr<Future<TValue, TAllocator, true>>;
+
+template<typename T>
+struct is_future : std::false_type {};
+
+template<typename TValue, template<typename> typename TAllocator, bool exceptions>
+struct is_future<Future<TValue, TAllocator, exceptions>> : std::true_type {};
+
+template<typename T>
+inline constexpr bool is_future_t = is_future<T>::value;
+
+template<typename T>
+concept FutureType = is_future<T>::value;
 
 //
 // public functions

source/mijin/container/boxed_object.hpp

@@ -68,12 +68,12 @@ public:
     BoxedObject(const BoxedObject&) = delete;
     BoxedObject(BoxedObject&&) = delete;
 
+#if MIJIN_BOXED_OBJECT_DEBUG
     constexpr ~BoxedObject() noexcept
     {
-#if MIJIN_BOXED_OBJECT_DEBUG
         MIJIN_ASSERT(!constructed, "BoxedObject::~BoxedObject(): Object has not been destroyed prior to destructor!");
-#endif
     }
+#endif
 
     BoxedObject& operator=(const BoxedObject&) = delete;
     BoxedObject& operator=(BoxedObject&&) = delete;

source/mijin/container/vector_map.hpp

@@ -133,7 +133,8 @@ public:
     VectorMap& operator=(VectorMap&&) = default;
     auto operator<=>(const VectorMap& other) const noexcept = default;
     
-    TValue& operator[](const TKey& key)
+    template<typename TIndex>
+    TValue& operator[](const TIndex& key)
     {
         auto it = find(key);
         if (it != end())
@@ -143,7 +144,8 @@ public:
         return emplace(key, TValue()).first->second;
     }
     
-    const TValue& operator[](const TKey& key) const
+    template<typename TIndex>
+    const TValue& operator[](const TIndex& key) const
     {
         return at(key);
     }
@@ -251,13 +253,13 @@ public:
         return eraseImpl(idx, count);
     }
 
-    template<std::equality_comparable_with<TKey> T>
+    template<typename TSearch>
     [[nodiscard]]
-    iterator find(const T& keyValue) MIJIN_NOEXCEPT
+    iterator find(const TSearch& key) MIJIN_NOEXCEPT
     {
         for (std::size_t idx = 0; idx < keys_.size(); ++idx)
         {
-            if (keys_[idx] == keyValue)
+            if (keys_[idx] == key)
             {
                 return iterator(&keys_[idx], &values_[idx]);
             }
@@ -265,13 +267,13 @@ public:
         return end();
     }
 
-    template<std::equality_comparable_with<TKey> T>
+    template<typename TSearch>
     [[nodiscard]]
-    const_iterator find(const T& keyValue) const MIJIN_NOEXCEPT
+    const_iterator find(const TSearch& key) const MIJIN_NOEXCEPT
     {
         for (std::size_t idx = 0; idx < keys_.size(); ++idx)
         {
-            if (keys_[idx] == keyValue)
+            if (keys_[idx] == key)
             {
                 return const_iterator(&keys_[idx], &values_[idx]);
             }
@@ -279,11 +281,10 @@ public:
         return end();
     }
 
-    template<std::equality_comparable_with<TKey> T>
     [[nodiscard]]
-    bool contains(const T& keyValue) const MIJIN_NOEXCEPT
+    bool contains(const TKey& key) const MIJIN_NOEXCEPT
     {
-        return std::ranges::contains(keys_, keyValue);
+        return std::ranges::contains(keys_, key);
     }
 private:
     iterator eraseImpl(std::ptrdiff_t idx, std::ptrdiff_t count = 1) MIJIN_NOEXCEPT

source/mijin/debug/assert.hpp

@@ -19,6 +19,7 @@
 #pragma comment(lib, "kernel32")
 extern "C" __declspec(dllimport) void __stdcall DebugBreak();
 #define MIJIN_TRAP() DebugBreak()
+#define MIJIN_FUNC() __FUNCSIG__
 #else // _WIN32
 #include <unistd.h>
 #define MIJIN_TRAP()                            \
@@ -33,6 +34,7 @@ extern "C" __declspec(dllimport) void __stdcall DebugBreak();
         : "rcx", "r11", "memory"                \
     );                                          \
 }
+#define MIJIN_FUNC() "" // TODO: __PRETTY_FUNCTION__ is not working for some reason -.-
 #endif // !_WIN32
 
 namespace mijin

source/mijin/debug/stacktrace.cpp

@@ -122,7 +122,7 @@ bool initDbgHelp() MIJIN_NOEXCEPT
         return false;
     }
 
-    const int result = std::atexit(&cleanupDbgHelp);
+    [[maybe_unused]] const int result = std::atexit(&cleanupDbgHelp);
     MIJIN_ASSERT(result == 0, "Error registering DbgHelp cleanup handler.");
 
     // only copy in the end so we can still figure out if initialization was successful

source/mijin/detect.hpp

@@ -61,6 +61,26 @@ namespace mijin
     #endif
 #endif
 
+#if !defined(MIJIN_RTTI)
+    #if MIJIN_COMPILER == MIJIN_COMPILER_GCC
+        #if defined(__GXX_RTTI)
+            #define MIJIN_RTTI 1
+        #else
+            #define MIJIN_RTTI 0
+        #endif
+    #elif MIJIN_COMPILER == MIJIN_COMPILER_CLANG
+        #define MIJIN_RTTI (__has_feature(cxx_rtti))
+    #elif MIJIN_COMPILER == MIJIN_COMPILER_MSVC
+        #if defined(_CPPRTTI)
+            #define MIJIN_RTTI 1
+        #else
+            #define MIJIN_RTTI 0
+        #endif
+    #else
+        #define MIJIN_RTTI 0
+    #endif
+#endif
+
 //
 // public constants
 //

source/mijin/io/stream.cpp

@@ -290,6 +290,29 @@ mijin::Task<StreamError> Stream::c_readLine(std::string& outString)
     co_return StreamError::SUCCESS;
 }
 
+StreamError Stream::copyTo(Stream& other)
+{
+    MIJIN_ASSERT(getFeatures().read, "Stream must support reading.");
+    MIJIN_ASSERT(other.getFeatures().write, "Other stream must support writing.");
+
+    static constexpr std::size_t CHUNK_SIZE = 4096;
+    std::array<std::byte, CHUNK_SIZE> chunk = {};
+
+    while (!isAtEnd())
+    {
+        std::size_t bytesRead = 0;
+        if (const StreamError error = readRaw(chunk, {.partial = true}, &bytesRead); error != StreamError::SUCCESS)
+        {
+            return error;
+        }
+        if (const StreamError error = other.writeRaw(chunk.data(), bytesRead); error != StreamError::SUCCESS)
+        {
+            return error;
+        }
+    }
+    return StreamError::SUCCESS;
+}
+
 FileStream::~FileStream()
 {
     if (handle) {
@@ -441,7 +464,7 @@ StreamFeatures FileStream::getFeatures()
     if (handle)
     {
         return {
-            .read = (mode == FileOpenMode::READ),
+            .read = (mode == FileOpenMode::READ || mode == FileOpenMode::READ_WRITE),
             .write = (mode == FileOpenMode::WRITE || mode == FileOpenMode::APPEND || mode == FileOpenMode::READ_WRITE),
             .tell = true,
             .seek = true,

source/mijin/io/stream.hpp

@@ -275,6 +275,8 @@ public:
 
     StreamError getTotalLength(std::size_t& outLength);
 
+    StreamError copyTo(Stream& otherStream);
+
     template<template<typename> typename TAllocator>
     StreamError readRest(BaseTypelessBuffer<TAllocator>& outBuffer);
 
@@ -544,7 +546,7 @@ inline void throwOnError(mijin::StreamError error)
     if (error == mijin::StreamError::SUCCESS) {
         return;
     }
-    throw std::runtime_error(errorName(error));
+    throw Exception(errorName(error));
 }
 
 inline void throwOnError(mijin::StreamError error, std::string message)
@@ -552,7 +554,7 @@ inline void throwOnError(mijin::StreamError error, std::string message)
     if (error == mijin::StreamError::SUCCESS) {
         return;
     }
-    throw std::runtime_error(message + ": " + errorName(error));
+    throw Exception(message + ": " + errorName(error));
 }
 
 template<typename TSuccess>

source/mijin/logging/debug_output_sink.hpp

@@ -0,0 +1,67 @@
+
+#pragma once
+
+#if !defined(MIJIN_LOGGING_DEBUG_OUTPUT_SINK_HPP_INCLUDED)
+#define MIJIN_LOGGING_DEBUG_OUTPUT_SINK_HPP_INCLUDED 1
+
+#include "./formatting.hpp"
+#include "../detect.hpp"
+#include "../util/traits.hpp"
+
+#if MIJIN_TARGET_OS == MIJIN_OS_WINDOWS
+#pragma comment(lib, "Kernel32.lib")
+
+extern "C" void OutputDebugStringA(const char* lpOutputString);
+extern "C" void OutputDebugStringW(const wchar_t* lpOutputString);
+
+namespace mijin
+{
+template<MIJIN_FORMATTING_SINK_TMPL_ARGS_INIT>
+    requires(allocator_type<TAllocator<TChar>>)
+class BaseDebugOutputSink : public BaseFormattingLogSink<MIJIN_FORMATTING_SINK_TMP_ARG_NAMES>
+{
+public:
+    using base_t = BaseFormattingLogSink<MIJIN_FORMATTING_SINK_TMP_ARG_NAMES>;
+    using typename base_t::char_t;
+    using typename base_t::allocator_t;
+    using typename base_t::formatter_ptr_t;
+    using typename base_t::message_t;
+public:
+    explicit BaseDebugOutputSink(formatter_ptr_t formatter, allocator_t allocator = {})
+        MIJIN_NOEXCEPT_IF(std::is_nothrow_move_constructible_v<allocator_t>)
+            : base_t(std::move(formatter), std::move(allocator)) {}
+
+    void handleMessageFormatted(const message_t&, const char_t* formatted) MIJIN_NOEXCEPT override
+    {
+        if constexpr (std::is_same_v<char_t, char>)
+        {
+            OutputDebugStringA(formatted);
+            OutputDebugStringA("\n");
+        }
+        else if constexpr (std::is_same_v<char_t, wchar_t>)
+        {
+            OutputDebugStringW(formatted);
+            OutputDebugStringW(L"\n");
+        }
+        else if constexpr (sizeof(char_t) == sizeof(char))
+        {
+            // char8_t etc.
+            OutputDebugStringA(std::bit_cast<const char*>(formatted));
+            OutputDebugStringA("\n");
+        }
+        else
+        {
+            static_assert(always_false_v<char_t>, "Character type not supported.");
+        }
+    }
+};
+
+#define SINK_SET_ARGS(chr_type) chr_type, std::char_traits<chr_type>, TAllocator, TDeleter
+
+MIJIN_DEFINE_CHAR_VERSIONS_TMPL(DebugOutputSink, MIJIN_FORMATTING_SINK_COMMON_ARGS, SINK_SET_ARGS)
+
+#undef SINK_SET_ARGS
+} // namespace mijin
+
+#endif // MIJIN_TARGET_OS == MIJIN_OS_WINDOWS
+#endif // !defined(MIJIN_LOGGING_DEBUG_OUTPUT_SINK_HPP_INCLUDED)

source/mijin/logging/formatting.hpp

@@ -92,10 +92,10 @@ public:
     using string_t = formatter_t::string_t;
     using typename base_t::message_t;
 private:
-    not_null_t<formatter_ptr_t> mFormatter;
+    formatter_ptr_t mFormatter;
     string_t mBuffer;
 public:
-    explicit BaseFormattingLogSink(not_null_t<formatter_ptr_t> formatter, allocator_t allocator = {})
+    explicit BaseFormattingLogSink(formatter_ptr_t formatter, allocator_t allocator = {})
         MIJIN_NOEXCEPT_IF(std::is_nothrow_move_constructible_v<allocator_t>)
         : mFormatter(std::move(formatter)), mBuffer(std::move(allocator))
     {}

source/mijin/logging/logger.hpp

@@ -12,7 +12,6 @@
 #include <vector>
 #include "../internal/common.hpp"
 #include "../util/annot.hpp"
-#include "../util/iterators.hpp"
 
 namespace mijin
 {
@@ -149,8 +148,11 @@ public:
     {}
 
     BaseLogger(const BaseLogger&) = default;
+
     BaseLogger(BaseLogger&&) = default;
+
     BaseLogger& operator=(const BaseLogger&) = default;
+
     BaseLogger& operator=(BaseLogger&&) = default;
 
     void addSink(sink_t& sink)
@@ -189,28 +191,12 @@ public:
 
     template<typename... TArgs>
     void log(const level_t& level, const channel_t& channel, std::source_location sourceLocation,
-             std::basic_format_string<char_t, std::type_identity_t<TArgs>...> fmt, TArgs&& ... args) const MIJIN_NOEXCEPT
+             std::basic_format_string<char_t, std::type_identity_t<TArgs>...> fmt, TArgs&& ... args) const
+             MIJIN_NOEXCEPT_IF(noexcept(std::declval<allocator_t>().allocate(1)))
     {
-        // TODO: make the logger use a traits struct to make this adjustable
-        static constexpr std::size_t BUFFER_SIZE = 256;
-        std::array<char_t, BUFFER_SIZE> buffer;
-
-        // first try to write into a buffer on the stack
-        FixedArrayOutputIterator itAfter = std::format_to(FixedArrayOutputIterator(buffer), fmt, std::forward<TArgs>(args)...);
-        *itAfter = '\0';
-        ++itAfter;
-        if (!itAfter.didOverflow())
-        {
-            log(level, channel, std::move(sourceLocation), buffer.data());
-            return;
-        }
-
-        // if that didn't work, allocate more space
-        const std::size_t newBufferSize = itAfter.getCounter();
-        char_t* newBuffer = static_cast<char_t*>(alloca(newBufferSize * sizeof(char_t)));
-        const std::format_to_n_result result = std::format_to_n(newBuffer, newBufferSize - 1, fmt, std::forward<TArgs>(args)...);
-        *result.out = '\0';
-        log(level, channel, std::move(sourceLocation), newBuffer);
+        string_t buffer(allocator_t(mSinks.get_allocator()));
+        std::format_to(std::back_inserter(buffer), fmt, std::forward<TArgs>(args)...);
+        log(level, channel, std::move(sourceLocation), buffer.c_str());
     }
 };
 
@@ -268,10 +254,14 @@ MIJIN_DEFINE_LOG_LEVEL(ERROR, MIJIN_LOG_LEVEL_VALUE_ERROR)
 #define MIJIN_LOG_ALWAYS(level, channel, ...) MIJIN_FUNCNAME_GET_LOGGER().log(                                     \
     MIJIN_LOG_LEVEL_OBJECT(level), MIJIN_LOG_CHANNEL_OBJECT(channel), std::source_location::current(), __VA_ARGS__ \
 )
-#define MIJIN_LOG(level, channel, ...)                                                    \
+#define MIJIN_LOG(level, channel, ...)                                                         \
 if constexpr (MIJIN_LOG_LEVEL_OBJECT(level).value < MIJIN_FUNCNAME_MIN_LOG_LEVEL_COMPILE()) {} \
 else MIJIN_LOG_ALWAYS(level, channel, __VA_ARGS__)
 
+#define MIJIN_LOG_IF(cond, level, channel, ...)                                                \
+if constexpr (MIJIN_LOG_LEVEL_OBJECT(level).value < MIJIN_FUNCNAME_MIN_LOG_LEVEL_COMPILE()) {} \
+else if (cond) MIJIN_LOG_ALWAYS(level, channel, __VA_ARGS__)
+
 #define MIJIN_SET_CLASS_LOGGER(loggerExpr)             \
 const auto& MIJIN_FUNCNAME_GET_LOGGER() const noexcept \
 {                                                      \
@@ -282,6 +272,11 @@ auto MIJIN_FUNCNAME_GET_LOGGER = [&]() -> const auto& \
 {                                                     \
     return loggerExpr;                                \
 };
+#define MIJIN_SET_NS_LOGGER(loggerExpr)                 \
+inline const mijin::Logger& MIJIN_FUNCNAME_GET_LOGGER() \
+{                                                       \
+    return loggerExpr;                                  \
+}
 #define MIJIN_SET_CLASS_MIN_LOG_LEVEL_COMPILE(level)      \
 int MIJIN_FUNCNAME_MIN_LOG_LEVEL_COMPILE() MIJIN_NOEXCEPT \
 {                                                         \

source/mijin/logging/stdio_sink.hpp

@@ -22,7 +22,7 @@ public:
 private:
     int mMinStderrLevel = MIJIN_LOG_LEVEL_VALUE_WARNING;
 public:
-    explicit BaseStdioSink(not_null_t<formatter_ptr_t> formatter, allocator_t allocator = {})
+    explicit BaseStdioSink(formatter_ptr_t formatter, allocator_t allocator = {})
         MIJIN_NOEXCEPT_IF(std::is_nothrow_move_constructible_v<allocator_t>)
         : base_t(std::move(formatter), std::move(allocator)) {}
 

source/mijin/memory/dynamic_pointer.hpp

@@ -35,10 +35,11 @@ public:
     {
         MIJIN_ASSERT((std::bit_cast<std::uintptr_t>(ptr) & 1) == 0, "Invalid address, DynamicPointer requires addresses to be divisible by two.");
     }
-    template<typename TOther, typename TOtherDeleter> requires (std::is_constructible_v<TDeleter, TOtherDeleter&&>)
+    template<typename TOther, typename TOtherDeleter> requires (std::is_assignable_v<T*&, TOther*> && std::is_constructible_v<TDeleter, TOtherDeleter&&>)
     constexpr DynamicPointer(DynamicPointer<TOther, TOtherDeleter>&& other) MIJIN_NOEXCEPT_IF((std::is_nothrow_convertible_v<TOtherDeleter, TDeleter>))
-        : mData(std::exchange(other.mData, 0)), mDeleter(std::move(other.mDeleter)) {
-        MIJIN_ASSERT(other.mData == 0, "");
+        : DynamicPointer(other.get(), other.isOwning() ? Owning::YES : Owning::NO, TDeleter(std::move(other.mDeleter)))
+    {
+        other.mData = 0;
     }
     constexpr ~DynamicPointer() noexcept
     {
@@ -64,6 +65,15 @@ public:
         return *this;
     }
 
+    // template<typename TOther, typename TOtherDeleter> requires (std::is_base_of_v<TOther, T>)
+    // constexpr operator DynamicPointer<TOther, TOtherDeleter>() && // MIJIN_NOEXCEPT_IF(std::is_nothrow_move_constructible_v<TDeleter>>)
+    // {
+    //     const Owning owning = isOwning() ? Owning::YES : Owning::NO;
+    //     T* const ptr = release();
+    // 
+    //     return DynamicPointer<TOther, TOtherDeleter>(static_cast<TOther*>(ptr), owning, TOtherDeleter(std::move(mDeleter)));
+    // }
+
     template<typename TOther, typename TOtherDeleter> requires(std::equality_comparable_with<T, TOther>)
     auto operator<=>(const DynamicPointer<TOther, TOtherDeleter>& other) MIJIN_NOEXCEPT
     {
@@ -155,9 +165,9 @@ bool operator!=(std::nullptr_t, const DynamicPointer<T, TDeleter>& pointer) MIJI
 }
 
 template<typename T, typename... TArgs>
-DynamicPointer<T, std::default_delete<T>> makeDynamic(TArgs&&... args) MIJIN_NOEXCEPT_IF((std::is_nothrow_constructible_v<T, TArgs...>))
+DynamicPointer<T> makeDynamic(TArgs&&... args) MIJIN_NOEXCEPT_IF((std::is_nothrow_constructible_v<T, TArgs...>))
 {
-    return DynamicPointer<T, std::default_delete<T>>(new T(std::forward<TArgs>(args)...), Owning::YES);
+    return DynamicPointer<T>(new T(std::forward<TArgs>(args)...), Owning::YES);
 }
 
 template<typename T, allocator_type_for<T> TAllocator, typename... TArgs>
@@ -171,6 +181,12 @@ DynamicPointer<T, AllocatorDeleter<TAllocator>> makeDynamicWithAllocator(TAlloca
     }
     return DynamicPointer<T, AllocatorDeleter<TAllocator>>(obj, Owning::YES, AllocatorDeleter<TAllocator>(std::move(allocator)));
 }
+
+template<typename T>
+DynamicPointer<T> wrapDynamic(T* raw)
+{
+    return DynamicPointer<T>(raw, Owning::NO);
+}
 } // namespace mijin
 
 #endif // !defined(MIJIN_MEMORY_DYNAMIC_POINTER_HPP_INCLUDED)

source/mijin/memory/object_pool.hpp

@@ -7,317 +7,56 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include "../internal/common.hpp"
+#include <limits>
+#include <memory>
+#include <vector>
 #include "../debug/assert.hpp"
-#include "../util/align.hpp"
 
 namespace mijin
 {
-namespace impl
-{
-struct ObjectPoolGap
-{
-    std::uint16_t nextGapOffset;
-    std::uint16_t remainingObjects;
-
-    ObjectPoolGap* nextGap() noexcept {
-        return nextGapOffset == 0 ? nullptr : reinterpret_cast<ObjectPoolGap*>(reinterpret_cast<std::byte*>(this) + nextGapOffset);
-    }
-};
-
-template<typename TObject, std::size_t OBJECTS_PER_PAGE>
-struct ObjectPoolPage
-{
-    ObjectPoolGap* firstGap;
-    ObjectPoolPage* nextPage = nullptr;
-    std::array<std::byte, OBJECTS_PER_PAGE * MIJIN_STRIDEOF(TObject)> data;
-
-    ObjectPoolPage() noexcept
-    {
-        firstGap = reinterpret_cast<ObjectPoolGap*>(data.data());
-        firstGap->nextGapOffset = 0;
-        firstGap->remainingObjects = OBJECTS_PER_PAGE;
-    }
-};
-}
-
-template<typename TObject, std::size_t OBJECTS_PER_PAGE>
-class ObjectPoolIterator
-{
-public:
-    using value_type = TObject;
-    using difference_type = std::ptrdiff_t;
-private:
-    using gap_t = impl::ObjectPoolGap;
-    using page_t = impl::ObjectPoolPage<TObject, OBJECTS_PER_PAGE>;
-
-    page_t* currentPage_ = nullptr;
-    gap_t* currentGap_ = nullptr;
-    std::uint16_t currentObject_ = 0;
-
-    explicit ObjectPoolIterator(page_t& firstPage) noexcept
-    {
-        seekNextOnPage(firstPage);
-    }
-public:
-    ObjectPoolIterator() noexcept = default;
-    ObjectPoolIterator(const ObjectPoolIterator&) noexcept = default;
-
-    ObjectPoolIterator& operator=(const ObjectPoolIterator&) noexcept = default;
-
-    auto operator<=>(const ObjectPoolIterator&) const noexcept = default;
-
-    TObject& operator*() const noexcept { return getObject(); }
-    TObject* operator->() const noexcept { return &getObject(); }
-
-    ObjectPoolIterator& operator++() noexcept
-    {
-        seekNext();
-        return *this;
-    }
-
-    ObjectPoolIterator operator++(int) const noexcept
-    {
-        ObjectPoolIterator copy(*this);
-        ++(*this);
-        return copy;
-    }
-private:
-    TObject& getObject() const noexcept
-    {
-        MIJIN_ASSERT(currentGap_ != nullptr, "Attempting to dereference an invalid iterator.");
-        return *(reinterpret_cast<TObject*>(currentGap_) + currentGap_->remainingObjects + currentObject_);
-    }
-
-    bool seekNextOnPage(page_t& firstPage) noexcept
-    {
-        for (page_t* page = &firstPage; page != nullptr; page = page->nextPage)
-        {
-            if (page->firstGap != nullptr && seekNextInGap(*page->firstGap))
-            {
-                currentPage_ = page;
-                return true;
-            }
-        }
-        return false;
-    }
-
-    bool seekNextInGap(gap_t& firstGap) noexcept
-    {
-        for (gap_t* gap = &firstGap; gap != nullptr; gap = gap->nextGap())
-        {
-            if (gap->remainingObjects < OBJECTS_PER_PAGE)
-            {
-                currentGap_ = gap;
-                currentObject_ = 0;
-                return true;
-            }
-        }
-        return false;
-    }
-
-    void seekNext() noexcept
-    {
-        if (++currentObject_ < OBJECTS_PER_PAGE - currentGap_->remainingObjects)
-        {
-            return;
-        }
-        if (currentGap_->nextGapOffset != 0 && seekNextInGap(*currentGap_->nextGap())) {
-            return;
-        }
-        if (currentPage_->nextPage != nullptr && seekNextOnPage(*currentPage_->nextPage)) {
-            return;
-        }
-        currentPage_ = nullptr;
-        currentGap_ = nullptr;
-        currentObject_ = 0;
-    }
-
-    template<typename TObject2, std::size_t OBJECTS_PER_PAGE2, template<typename> typename TAllocator>
-    friend class ObjectPool;
-};
-
-template<typename TObject, std::size_t OBJECTS_PER_PAGE = 1024, template<typename> typename TAllocator = MIJIN_DEFAULT_ALLOCATOR>
+template<typename TObject, std::size_t OBJECTS_PER_PAGE = 1024>
 class ObjectPool
 {
-public:
-    using iterator = ObjectPoolIterator<TObject, OBJECTS_PER_PAGE>;
-    using const_iterator = iterator;
 private:
-    using gap_t = impl::ObjectPoolGap;
-    using page_t = impl::ObjectPoolPage<TObject, OBJECTS_PER_PAGE>;
-    
-    static_assert(sizeof(gap_t) <= sizeof(TObject));
+    struct GapInfo
+    {
+        std::uint32_t objectCount;
+        std::uint32_t nextGap;
+    };
+    static constexpr std::size_t ALIGN = std::max(alignof(TObject), alignof(GapInfo));
 
-    [[no_unique_address]] TAllocator<page_t> allocator_;
-    page_t* firstPage = nullptr;
+    struct alignas(ALIGN) ObjectData
+    {
+        std::array<std::byte, sizeof(TObject)> bytes;
+    };
+    struct Page
+    {
+        std::uint32_t freeOffset = 0;
+        std::array<ObjectData, OBJECTS_PER_PAGE> data;
+    };
+
+    std::vector<std::unique_ptr<Page>> pages;
 public:
-    explicit ObjectPool(TAllocator<void> allocator = {}) MIJIN_NOEXCEPT_IF((std::is_nothrow_constructible_v<TAllocator<page_t>, TAllocator<void>&&>))
-        : allocator_(std::move(allocator))
-    {
-    }
-    ObjectPool(const ObjectPool&) = delete;
-    ObjectPool(ObjectPool&&) = default;
-
-    ObjectPool& operator=(const ObjectPool&) = delete;
-    ObjectPool& operator=(ObjectPool&&) = default;
-
-    [[nodiscard]]
-    TObject* allocate(std::size_t count = 1) noexcept
-    {
-        MIJIN_ASSERT(count <= OBJECTS_PER_PAGE, "Cannot allocate that many objects at once.");
-
-        // first try to find a free spot in the existing pages
-        for (page_t* page = firstPage; page != nullptr; page = page->nextPage)
-        {
-            if (TObject* result = allocateFromPage(*page, count); result != nullptr) {
-                return result;
-            }
-        }
-
-        // nothing found in the existing pages, allocate a new one and return memory from there
-        page_t* newPage = ::new (allocator_.allocate(1)) page_t;
-
-        if (firstPage == nullptr)
-        {
-            firstPage = newPage;
-        }
-        else
-        {
-            page_t* lastPage = firstPage;
-            for (; lastPage->nextPage != nullptr; lastPage = lastPage->nextPage);
-            lastPage->nextPage = newPage;
-        }
-        return allocateFromPage(*newPage, count);
-    }
-
-    void deallocate(TObject* object, std::size_t count = 1) noexcept
-    {
-        std::byte* const objectPtr = reinterpret_cast<std::byte*>(object); // for easier comparison
-        for (page_t* page = firstPage; page != nullptr; page = page->nextPage)
-        {
-            // first find the page it's in
-            std::byte* pageStart = page->data.data();
-            std::byte* pageEnd = pageStart + (OBJECTS_PER_PAGE * sizeof(TObject));
-
-            if (objectPtr >= pageStart && objectPtr <= pageEnd)
-            {
-                // then the corresponding gap
-                if (page->firstGap == nullptr)
-                {
-                    // everything is used, create a new gap
-                    gap_t* newGap = reinterpret_cast<gap_t*>(objectPtr);
-                    newGap->remainingObjects = count;
-                    newGap->nextGapOffset = 0;
-                    page->firstGap = newGap;
-                    return;
-                }
-
-                for (gap_t* gap = page->firstGap; gap != nullptr; gap = gap->nextGap())
-                {
-                    std::byte* gapStart = reinterpret_cast<std::byte*>(gap);
-                    std::byte* gapEnd = gap->nextGapOffset == 0 ? pageEnd : gapStart + gap->nextGapOffset;
-                    if (objectPtr > gapStart && objectPtr < gapEnd)
-                    {
-                        if (objectPtr + (count * sizeof(TObject)) == gapEnd)
-                        {
-                            // deallocating right from the end -> just increase the gap remainingObjects
-                            gap->remainingObjects += count;
-                            mergeGaps(gap);
-                        }
-                        else
-                        {
-                            // deallocating from the middle -> create a new gap
-                            gap_t* newGap = reinterpret_cast<gap_t*>(objectPtr);
-                            newGap->remainingObjects = count;
-                            newGap->nextGapOffset = gap->nextGapOffset == 0 ? 0 : (gapEnd - reinterpret_cast<std::byte*>(newGap));
-                            gap->nextGapOffset -= objectPtr - gapStart;
-                            mergeGaps(newGap);
-                        }
-                        return;
-                    }
-                }
-            }
-        }
-    }
-
-    template<typename... TArgs>
-    [[nodiscard]]
-    TObject* create(TArgs&&... args) noexcept
-    {
-        TObject* result = allocate();
-        if (result == nullptr) {
-            return nullptr;
-        }
-        return ::new (result) TObject(std::forward<TArgs>(args)...);
-    }
-
-    [[nodiscard]]
-    TObject* createMultiple(std::size_t count = 1) noexcept
-    {
-        TObject* result = allocate(count);
-        if (result == nullptr) {
-            return nullptr;
-        }
-        return ::new (result) TObject[count];
-    }
-
-    void destroy(TObject* ptr, std::size_t count = 1) noexcept
-    {
-        for (std::size_t idx = 0; idx < count; ++idx) {
-            ptr[idx].~TObject();
-        }
-        deallocate(ptr, count);
-    }
-
-    [[nodiscard]]
-    iterator begin() const noexcept { return firstPage != nullptr ? iterator(*firstPage) : iterator(); }
-
-    [[nodiscard]]
-    iterator end() const noexcept { return {}; }
-private:
-    TObject* allocateFromPage(page_t& page, std::size_t count)
-    {
-        gap_t* previousGap = nullptr;
-        for (gap_t* gap = page.firstGap; gap != nullptr; previousGap = gap, gap = gap->nextGap())
-        {
-            if (gap->remainingObjects == count)
-            {
-                // exactly the correct size
-                if (previousGap != nullptr) {
-                    previousGap->nextGapOffset += gap->nextGapOffset;
-                }
-                else {
-                    page.firstGap = gap->nextGap();
-                }
-                return reinterpret_cast<TObject*>(gap);
-            }
-            else if (gap->remainingObjects > count)
-            {
-                // still enough space
-                TObject* memory = reinterpret_cast<TObject*>(gap) + gap->remainingObjects - count;
-                gap->remainingObjects -= count;
-                return reinterpret_cast<TObject*>(memory);
-            }
-        }
-        return nullptr;
-    }
-
-    void mergeGaps(gap_t* start) noexcept
-    {
-        while (start->nextGapOffset != 0 && start->remainingObjects == start->nextGapOffset * sizeof(TObject))
-        {
-            gap_t& next = *start->nextGap();
-            start->remainingObjects += start->nextGap()->remainingObjects;
-            if (next.nextGapOffset == 0) {
-                start->nextGapOffset = 0;
-            }
-            else {
-                start->nextGapOffset += next.nextGapOffset;
-            }
-        }
-    }
+    [[nodiscard]] TObject* allocate(std::size_t count = 1) noexcept;
+    void free(TObject* object, std::size_t count = 1) noexcept;
 };
+
+template<typename TObject, std::size_t OBJECTS_PER_PAGE>
+TObject* ObjectPool<TObject, OBJECTS_PER_PAGE>::allocate(std::size_t count) noexcept
+{
+    MIJIN_ASSERT(count <= OBJECTS_PER_PAGE, "Cannot allocate more than OBJECTS_PER_PAGE elements at once!");
+    // first try to find a free spot in the existing pages
+
+    for (std::unique_ptr<Page>& page : pages)
+    {
+        std::uint32_t offset = page->freeOffset;
+        while (offset < OBJECTS_PER_PAGE)
+        {
+            GapInfo& gapInfo = *std::bit_cast<GapInfo*>(&page->data[offset]);
+            
+        }
+    }
+}
 } // namespace mijin
 
 #endif // !defined(MIJIN_MEMORY_OBJECT_POOL_HPP_INCLUDED)

source/mijin/types/path.cpp

@@ -1,40 +0,0 @@
-
-#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

source/mijin/types/path.hpp

@@ -1,511 +0,0 @@
-
-#pragma once
-
-#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 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
-{
-private:
-    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:
-    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_};
-    }
-
-    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;
-    }
-
-    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]]
-    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:
-    constexpr void simplify() MIJIN_NOEXCEPT;
-};
-
-using Path = BasePath<char>;
-using WPath = BasePath<wchar_t>;
-
-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
-        if (moveBy > 0) {
-            *std::prev(it, moveBy) = *it;
-        }
-        if (doubleSlash) {
-            ++moveBy;
-        }
-    }
-    // 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) {
-        ++moveBy;
-    }
-    storage_.resize(storage_.size() - moveBy);
-
-    // step 2: get rid of any "/.." together with the preceeding segment
-    moveBy = 0;
-    for (auto it = std::next(storage_.begin(), 2); it < storage_.end(); ++it)
-    {
-        if (moveBy > 0)
-        {
-            *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 + 2) == storage_.begin())
-            {
-                // leading "/.." -> just remove it
-                moveBy += 3;
-                continue;
-            }
-            // 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())
-                {
-                    //     /path/with/../double/dot
-                    // itStart --A     A
-                    // it -------------|
-                    // remove everything from itStart to it + two slashes
-                    moveBy += std::distance(itStart, std::prev(it, moveBy)) + 2; // skip it all
-                    break;
-                }
-            }
-        }
-    }
-    storage_.resize(storage_.size() - moveBy);
-
-    // step 3: eliminate any segments that are just "."
-    moveBy = 0;
-    if (storage_.size() == 1) {
-        return; // just stop it here
-    }
-    for (auto it = storage_.begin(); it < storage_.end(); ++it)
-    {
-        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
-        if (moveBy > 0) {
-            *std::prev(it, moveBy) = *it;
-        }
-        if (emptyEle) {
-            moveBy += 2;
-            if (!atEnd) {
-                ++it; // skip the next one
-            }
-        }
-    }
-    storage_.resize(storage_.size() - moveBy);
-}
-
-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)

source/mijin/types/result.hpp

@@ -60,6 +60,32 @@ public:
     [[nodiscard]] const TError& getError() const MIJIN_NOEXCEPT { return std::get<TError>(state_); }
 };
 
+namespace impl
+{
+struct ResultSuccess {};
+}
+
+template<typename TError>
+class ResultBase<void, TError> : public ResultBase<impl::ResultSuccess, TError>
+{
+public:
+    ResultBase() MIJIN_NOEXCEPT : ResultBase<impl::ResultSuccess, TError>(impl::ResultSuccess{}) {}
+    ResultBase(const ResultBase&) MIJIN_NOEXCEPT = default;
+    ResultBase(ResultBase&&) MIJIN_NOEXCEPT = default;
+    ResultBase(TError errorValue) MIJIN_NOEXCEPT : ResultBase<impl::ResultSuccess, TError>(std::move(errorValue)) {}
+
+    ResultBase& operator=(const ResultBase&) = default;
+    ResultBase& operator=(ResultBase&&) = default;
+    
+    impl::ResultSuccess& operator*() MIJIN_NOEXCEPT = delete;
+    const impl::ResultSuccess& operator*() const MIJIN_NOEXCEPT = delete;
+    impl::ResultSuccess* operator->() MIJIN_NOEXCEPT = delete;
+    const impl::ResultSuccess* operator->() const MIJIN_NOEXCEPT = delete;
+
+    [[nodiscard]] impl::ResultSuccess& getValue() MIJIN_NOEXCEPT = delete;
+    [[nodiscard]] const impl::ResultSuccess& getValue() const MIJIN_NOEXCEPT = delete;
+};
+
 struct ResultError
 {
     std::string message;
@@ -73,7 +99,7 @@ struct ResultError
     ResultError& operator=(ResultError&&) MIJIN_NOEXCEPT = default;
 };
 
-template<typename TSuccess>
+template<typename TSuccess = void>
 using Result = ResultBase<TSuccess, ResultError>;
 
 //

source/mijin/util/annot.hpp

@@ -35,10 +35,6 @@ concept nullable_type = !std::is_same_v<T, std::nullptr_t> && requires(T t) { t
 template<nullable_type T>
 class NotNullable
 {
-public:
-    using wrapped_t = T;
-    using element_type = std::remove_reference_t<decltype(*std::declval<const wrapped_t>())>;
-    using pointer = element_type*;
 private:
     T base_;
 public:
@@ -59,12 +55,6 @@ public:
     {
         MIJIN_ASSERT(base_ != nullptr, "Constructed non-nullable type with nullptr.");
     }
-    template<typename TOther> requires(std::is_base_of_v<typename NotNullable<TOther>::element_type, element_type> && std::is_constructible_v<T, pointer>)
-    explicit constexpr NotNullable(const NotNullable<TOther>& other) MIJIN_NOEXCEPT_IF((std::is_nothrow_constructible_v<T, pointer>))
-            : base_(static_cast<pointer>(&*other))
-    {
-        MIJIN_ASSERT(base_ != nullptr, "Constructed non-nullable type with nullptr.");
-    }
     template<typename TOther> requires(std::is_constructible_v<T, TOther&&>)
     constexpr NotNullable(NotNullable<TOther>&& other) MIJIN_NOEXCEPT_IF((std::is_nothrow_constructible_v<T, TOther&&>))
             : base_(std::exchange(other.base_, nullptr))

source/mijin/util/common_macros.hpp

@@ -4,18 +4,8 @@
 #if !defined(MIJIN_UTIL_COMMON_MACROS_HPP_INCLUDED)
 #define MIJIN_UTIL_COMMON_MACROS_HPP_INCLUDED 1
 
-#include "../detect.hpp"
-
 #define MIJIN_CONCAT_DETAIL(a, b) a ## b
 #define MIJIN_CONCAT(a, b) MIJIN_CONCAT_DETAIL(a, b)
 #define MIJIN_CONCAT3(a, b, c) MIJIN_CONCAT(a, MIJIN_CONCAT(b, c))
 
-#if MIJIN_COMPILER == MIJIN_COMPILER_GCC || MIJIN_COMPILER == MIJIN_COMPILER_CLANG
-#define MIJIN_FUNCNAME() __PRETTY_FUNCTION__
-#elif MIJIN_COMPILER == MIJIN_COMPILER_MSVC
-#define MIJIN_FUNCNAME() __FUNCSIG__
-#else
-#define MIJIN_FUNCNAME() __func__
-#endif
-
 #endif // defined(MIJIN_UTIL_COMMON_MACROS_HPP_INCLUDED)

source/mijin/util/exception.hpp

@@ -4,8 +4,11 @@
 #ifndef MIJIN_UTIL_EXCEPTION_HPP_INCLUDED
 #define MIJIN_UTIL_EXCEPTION_HPP_INCLUDED 1
 
+#include <format>
 #include <stdexcept>
+#include <typeinfo>
 
+#include "../detect.hpp"
 #include "../debug/stacktrace.hpp"
 
 namespace mijin
@@ -73,5 +76,76 @@ void walkExceptionCause(const std::exception_ptr& cause, TFunc func)
         }
     }
 }
+
+template<typename TFunc>
+void walkException(const std::exception& exc, TFunc func)
+{
+    func(exc);
+}
+
+template<typename TFunc>
+void walkException(const mijin::Exception& exc, TFunc func)
+{
+    func(exc);
+    walkExceptionCause(exc.getCause(), func);
+}
 } // namespace mijin
+
+template<typename TChar>
+struct std::formatter<mijin::Exception, TChar>
+{
+    using char_t = TChar;
+
+    template<class TContext>
+    constexpr TContext::iterator parse(TContext& ctx)
+    {
+        auto it = ctx.begin();
+        auto end = ctx.end();
+
+        if (it != end && *it != MIJIN_SMART_QUOTE(char_t, '}'))
+        {
+            throw std::format_error("invalid format");
+        }
+
+        return it;
+    }
+
+    template<typename TContext>
+    TContext::iterator format(const mijin::Exception& exception, TContext& ctx) const
+    {
+        using namespace std::literals;
+
+        auto it = ctx.out();
+        bool first = true;
+        mijin::walkException(exception, [&]<typename T>(const T& exc)
+        {
+            if constexpr (!std::is_same_v<T, std::nullptr_t>)
+            {
+                if (!first) {
+                    it = std::ranges::copy(MIJIN_SMART_QUOTE(char_t, "\nCaused by:\n"sv), it).out;
+                }
+                first = false;
+#if MIJIN_RTTI
+                it = std::ranges::copy(std::basic_string_view(typeid(exc).name()), it).out;
+                it = std::ranges::copy(MIJIN_SMART_QUOTE(char_t, ": "sv), it).out;
+#endif
+                it = std::ranges::copy(std::basic_string_view(exc.what()), it).out;
+                if constexpr (std::is_same_v<T, mijin::Exception>)
+                {
+                    if (const mijin::Result<mijin::Stacktrace>& trace = exc.getStacktrace(); trace.isSuccess())
+                    {
+                        *it = MIJIN_SMART_QUOTE(char_t, '\n');
+                        ++it;
+                        it = std::format_to(it, MIJIN_SMART_QUOTE(char_t, "{}"), trace.getValue());
+                    }
+                }
+            }
+            else
+            {
+                it = std::ranges::copy(MIJIN_SMART_QUOTE(char_t, "<unknown exception>"sv), it).out;
+            }
+        });
+        return it;
+    }
+};
 #endif // MIJIN_UTIL_EXCEPTION_HPP_INCLUDED

source/mijin/util/formattable.hpp

@@ -1,122 +0,0 @@
-
-#pragma once
-
-#ifndef MIJIN_UTIL_FORMATTABLE_HPP_INCLUDED
-#define MIJIN_UTIL_FORMATTABLE_HPP_INCLUDED 1
-
-#include <format>
-#include "../container/boxed_object.hpp"
-
-namespace mijin
-{
-
-//
-// public concepts
-//
-
-template<typename T>
-concept parse_result_type = requires
-{
-    typename T::parse_result_t;
-};
-
-template<typename T, typename TParseContext>
-concept parseable_by_type = parse_result_type<T> &&
-        requires(const T& object, TParseContext& parseContext)
-{
-    { T::parseFormat(parseContext) } -> std::convertible_to<std::pair<typename TParseContext::iterator, typename T::parse_result_t>>;
-};
-
-template<typename T, typename TFmtContext>
-concept simple_formattable_to_type = requires(const T& object, TFmtContext& formatContext)
-{
-    { object.format(formatContext) } -> std::convertible_to<typename TFmtContext::iterator>;
-};
-
-template<typename T, typename TFmtContext, typename TParseContext>
-concept complex_formattable_to_type = parseable_by_type<T, TParseContext> &&
-        requires(const T& object, TParseContext& parseContext, TFmtContext& formatContext, T::parse_result_t& parseResult)
-{
-    { object.format(formatContext, parseResult) } -> std::convertible_to<typename TFmtContext::iterator>;
-};
-
-template<typename T, typename TFmtContext, typename TParseContext>
-concept formattable_to_type = simple_formattable_to_type<T, TFmtContext> || complex_formattable_to_type<T, TFmtContext, TParseContext>;
-
-template<typename T>
-concept cformattable_type = formattable_to_type<T, std::format_context, std::format_parse_context>;
-
-template<typename T>
-concept wformattable_type = formattable_to_type<T, std::wformat_context, std::wformat_parse_context>;
-
-template<typename T>
-concept formattable_type = cformattable_type<T> && wformattable_type<T>;
-
-template<typename T>
-concept any_formattable_type = cformattable_type<T> || wformattable_type<T>;
-
-//
-// internal types
-//
-
-namespace impl
-{
-template<typename T>
-struct ParseResult
-{
-};
-
-template<parse_result_type T>
-struct ParseResult<T>
-{
-    BoxedObject<typename T::parse_result_t> value;
-};
-}
-} // namespace mijin
-
-template<mijin::any_formattable_type T>
-struct std::formatter<T>
-{
-    [[no_unique_address]] [[maybe_unused]] mijin::impl::ParseResult<T> parseResult;
-
-    template<typename TContext>
-    constexpr TContext::iterator parse(TContext& ctx)
-    {
-        if constexpr (mijin::parse_result_type<T>)
-        {
-            static_assert(mijin::parseable_by_type<T, TContext>, "Type does not support parsing by this context.");
-            auto [it, result] = T::parseFormat(ctx);
-            parseResult.value.construct(std::move(result));
-            return it;
-        }
-        else
-        {
-            auto it = ctx.begin();
-            auto end = ctx.end();
-
-            if (it != end && *it != '}')
-            {
-                throw std::format_error("invalid format");
-            }
-
-            return it;
-        }
-    }
-
-    template<typename TContext>
-    TContext::iterator format(const T& object, TContext& ctx) const
-    {
-        if constexpr (mijin::parse_result_type<T>)
-        {
-            auto it = object.format(ctx, std::move(*parseResult.value));
-            parseResult.destroy();
-            return it;
-        }
-        else
-        {
-            static_assert(mijin::simple_formattable_to_type<T, TContext>, "Type does not support formatting to this context.");
-            return object.format(ctx);
-        }
-    }
-};
-#endif // MIJIN_UTIL_FORMATTABLE_HPP_INCLUDED

source/mijin/util/iterators.hpp

@@ -3,7 +3,6 @@
 #if !defined(MIJIN_UTIL_ITERATORS_HPP_INCLUDED)
 #define MIJIN_UTIL_ITERATORS_HPP_INCLUDED 1
 
-#include <array>
 #include <cstddef>
 #include <functional>
 #include <optional>
@@ -14,7 +13,6 @@
 #include <variant>
 #include "../container/optional.hpp"
 #include "../internal/common.hpp"
-#include "../util/annot.hpp"
 
 namespace mijin
 {
@@ -857,64 +855,6 @@ TAs collect(TIterable&& iterable)
     return TAs(iterable.begin(), iterable.end());
 }
 
-template<typename TEle, std::size_t numEles>
-class FixedArrayOutputIterator
-{
-public:
-    using array_t = std::array<TEle, numEles>;
-    using difference_type = std::ptrdiff_t;
-    using value_type = TEle;
-    using pointer = value_type*;
-    using reference = value_type&;
-
-    static constexpr std::size_t NUM_ELES = numEles;
-private:
-    not_null_t<array_t*> array_;
-    std::size_t counter_ = 0;
-public:
-    constexpr explicit FixedArrayOutputIterator(array_t& array) MIJIN_NOEXCEPT : array_(&array) {}
-    constexpr explicit FixedArrayOutputIterator(array_t& array, array_t::iterator pos) MIJIN_NOEXCEPT
-            : array_(&array), counter_(static_cast<std::size_t>(pos - array.begin())) {}
-    constexpr FixedArrayOutputIterator(const FixedArrayOutputIterator&) noexcept = default;
-
-    constexpr FixedArrayOutputIterator& operator=(const FixedArrayOutputIterator&) noexcept = default;
-
-    [[nodiscard]]
-    constexpr std::size_t getCounter() const MIJIN_NOEXCEPT
-    {
-        return counter_;
-    }
-
-    [[nodiscard]]
-    constexpr bool didOverflow() const MIJIN_NOEXCEPT
-    {
-        return counter_ >= NUM_ELES;
-    }
-
-    constexpr reference operator*() const MIJIN_NOEXCEPT
-    {
-        static TEle dummy_; // returned when we're at the end of the array
-        if (counter_ < NUM_ELES) {
-            return array_->at(counter_);
-        }
-        return dummy_;
-    }
-
-    constexpr FixedArrayOutputIterator& operator++() MIJIN_NOEXCEPT
-    {
-        ++counter_;
-        return *this;
-    }
-
-    constexpr FixedArrayOutputIterator operator++(int) const MIJIN_NOEXCEPT
-    {
-        FixedArrayOutputIterator copy(*this);
-        ++copy;
-        return copy;
-    }
-};
-static_assert(std::output_iterator<FixedArrayOutputIterator<int, 1>, int>);
-
 namespace pipe
 {
 template<typename T>
@@ -1033,7 +973,7 @@ auto operator|(TIterable&& iterable, Xth<idx>)
 {
     return map(std::forward<TIterable>(iterable), [](auto&& element) { return std::get<idx>(element); } );
 }
-} // namespace pipe
+}
 } // namespace mijin
 
 #endif // MIJIN_UTIL_ITERATORS_HPP_INCLUDED

source/mijin/util/os.cpp

@@ -10,7 +10,6 @@
     #include <mutex>
     #include <dlfcn.h>
     #include <pthread.h>
-    #include <time.h>
 #elif MIJIN_TARGET_OS == MIJIN_OS_WINDOWS
     #include <array>
     #include <malloc.h>
@@ -39,29 +38,12 @@ namespace mijin
 // internal variables
 //
 
+#if MIJIN_TARGET_OS == MIJIN_OS_LINUX
 namespace
 {
-#if MIJIN_TARGET_OS == MIJIN_OS_LINUX
 std::mutex gDlErrorMutex; // dlerror may not be thread-safe
-
-const std::uint64_t gCPUClockResolution = []()
-{
-    struct timespec time;
-    [[maybe_unused]] const int result = clock_getres(CLOCK_PROCESS_CPUTIME_ID, &time);
-    MIJIN_ASSERT(result == 0, "Error getting cputime resolution.");
-    MIJIN_ASSERT(time.tv_sec == 0, "What kind of cpu clock is this?");
-    return static_cast<std::uint64_t>(time.tv_nsec);
-}();
-#elif MIJIN_TARGET_OS == MIJIN_OS_WINDOWS
-const std::uint64_t gCPUTickFrequency = []()
-{
-    LARGE_INTEGER ticks;
-    [[maybe_unused]] const BOOL result = QueryPerformanceFrequency(&ticks);
-    MIJIN_ASSERT(result, "Error getting cpu frequency.");
-    return static_cast<std::uint64_t>(ticks.QuadPart);
-}();
-#endif // MIJIN_TARGET_OS == MIJIN_OS_LINUX || MIJIN_TARGET_OS == MIJIN_OS_WINDOWS
 }
+#endif // MIJIN_TARGET_OS == MIJIN_OS_LINUX
 
 //
 // internal functions
@@ -196,27 +178,4 @@ void alignedFree(void* ptr)
 #endif
 }
 
-std::uint64_t getCPUTicks() MIJIN_NOEXCEPT
-{
-#if MIJIN_TARGET_OS == MIJIN_OS_LINUX
-    struct timespec time;
-    [[maybe_unused]] const int result = clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time);
-    MIJIN_ASSERT(result == 0, "Error getting cpu time.");
-    return (static_cast<std::uint64_t>(time.tv_sec) * 1e9 + time.tv_nsec) / gCPUClockResolution;
-#else
-    LARGE_INTEGER ticks;
-    [[maybe_unused]] const BOOL result = QueryPerformanceCounter(&ticks);
-    MIJIN_ASSERT(result, "Error getting cpu time.");
-    return static_cast<std::uint64_t>(ticks.QuadPart);
-#endif
-}
-
-std::uint64_t getCPUTicksPerSecond() MIJIN_NOEXCEPT
-{
-#if MIJIN_TARGET_OS == MIJIN_OS_LINUX
-    return 1e9 / gCPUClockResolution;
-#else
-    return gCPUTickFrequency;
-#endif
-}
 } // namespace mijin

source/mijin/util/os.hpp

@@ -5,7 +5,6 @@
 #define MIJIN_UTIL_OS_HPP_INCLUDED 1
 
 #include <csignal>
-#include <cstdint>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -86,9 +85,6 @@ void setCurrentThreadName(const char* threadName) MIJIN_NOEXCEPT;
 [[nodiscard]] void* alignedRealloc(void* ptr, std::size_t alignment, std::size_t size) MIJIN_NOEXCEPT;
 void alignedFree(void* ptr);
 
-[[nodiscard]] std::uint64_t getCPUTicks() MIJIN_NOEXCEPT;
-[[nodiscard]] std::uint64_t getCPUTicksPerSecond() MIJIN_NOEXCEPT;
-
 SharedLibrary::~SharedLibrary() MIJIN_NOEXCEPT
 {
     close();

source/mijin/util/string.hpp

@@ -1020,6 +1020,54 @@ bool convertStringType(const TFrom* strFrom, std::basic_string<TTo, TToTraits, T
 {
     return convertStringType(std::basic_string_view<TFrom>(strFrom), outString);
 }
+
+struct StringQuoteOptions
+{
+    bool replaceNewlines = false;
+};
+
+template<StringQuoteOptions options = {}, typename TChar, typename TTraits, typename TAlloc = MIJIN_DEFAULT_ALLOCATOR<TChar>>
+std::basic_string<TChar, TTraits, TAlloc> quoted(std::basic_string_view<TChar, TTraits> input)
+{
+    std::basic_string<TChar, TTraits> result;
+    result.reserve(input.size() + 2);
+    result.push_back(TChar('"'));
+    for (const TChar chr : input)
+    {
+        switch (chr)
+        {
+        case TChar('"'):
+        case TChar('\\'):
+            result.push_back(TChar('\\'));
+            break;
+        case TChar('\n'):
+            if constexpr (options.replaceNewlines)
+            {
+                result.push_back(TChar('\\'));
+                result.push_back(TChar('n'));
+                continue;
+            }
+            break;
+        case TChar('\r'):
+            if constexpr (options.replaceNewlines)
+            {
+                result.push_back(TChar('\\'));
+                result.push_back(TChar('r'));
+                continue;
+            }
+            break;
+        }
+        result.push_back(chr);
+    }
+    result.push_back(TChar('"'));
+    return result;
+}
+
+template<StringQuoteOptions options = {}, typename TChar, typename TTraits, typename TAlloc>
+std::basic_string<TChar, TTraits, TAlloc> quoted(const std::basic_string<TChar, TTraits, TAlloc>& input)
+{
+    return quoted<options, TChar, TTraits, TAlloc>(std::basic_string_view(input));
+}
 } // namespace mijin
 
 #endif // !defined(MIJIN_UTIL_STRING_HPP_INCLUDED)

source/mijin/util/traits.hpp

@@ -192,6 +192,18 @@ struct is_type_member<TElement, TCollection<Ts...>>
 template<typename TElement, typename TCollection>
 constexpr bool is_type_member_v = is_type_member<TElement, TCollection>::value;
 
+template<typename T, typename TObject>
+struct is_member_object_pointer_of : std::false_type {};
+
+template<typename TMember, typename TObject>
+struct is_member_object_pointer_of<TMember (TObject::*), TObject> : std::true_type {};
+
+template<typename T, typename TObject>
+inline constexpr bool is_member_object_pointer_of_v = is_member_object_pointer_of<T, TObject>::value;
+
+template<typename T, typename TObject>
+concept member_object_pointer_of = is_member_object_pointer_of_v<T, TObject>;
+
 template<typename TFrom, typename TTo>
 using copy_const_t = std::conditional_t<std::is_const_v<TFrom>, std::add_const_t<TTo>, std::remove_const_t<TTo>>;
 
@@ -253,42 +265,6 @@ struct optional_base<T, false>
 template<typename T, bool enable>
 using optional_base_t = optional_base<T, enable>::type;
 
-namespace impl
-{
-template<typename TFunc>
-struct function_traits_base {};
-
-template<typename TResult, typename... TParams>
-struct function_traits_base<TResult (*)(TParams...)>
-{
-    using result_t = TResult;
-    using params_t = std::tuple<TParams...>;
-};
-
-template<typename TResult, typename TType, typename... TParams>
-struct function_traits_base<TResult (TType::*)(TParams...)>
-{
-    using result_t = TResult;
-    using params_t = std::tuple<TType*, TParams...>;
-};
-
-template<typename TResult, typename TType, typename... TParams>
-struct function_traits_base<TResult (TType::*)(TParams...) const>
-{
-    using result_t = TResult;
-    using params_t = std::tuple<const TType*, TParams...>;
-};
-}
-
-template<typename TFunc>
-struct function_traits : impl::function_traits_base<TFunc>
-{
-    static constexpr std::size_t NUM_PARAMS = std::tuple_size_v<typename impl::function_traits_base<TFunc>::params_t>;
-
-    template<std::size_t pos>
-    using param_t = std::tuple_element_t<pos, typename impl::function_traits_base<TFunc>::params_t>;
-};
-
 //
 // public functions
 //

source/mijin/util/variant.hpp

@@ -4,7 +4,6 @@
 #if !defined(MIJIN_UTIL_VARIANT_HPP_INCLUDED)
 #define MIJIN_UTIL_VARIANT_HPP_INCLUDED 1
 
-#include <utility>
 #include <variant>
 #include "./traits.hpp"
 
@@ -24,21 +23,10 @@ inline constexpr bool variant_contains_v<TSearch, std::variant<TVariantTypes...>
 //
 // public types
 //
-
 template<typename... TCallable>
 struct Visitor : TCallable ...
 {
     using TCallable::operator()...;
 };
-
-template<typename TRet>
-struct CastTo
-{
-    template<typename T>
-    TRet operator()(T&& arg) const
-    {
-        return static_cast<TRet>(std::forward<T>(arg));
-    }
-};
 }
 #endif // !defined(MIJIN_UTIL_VARIANT_HPP_INCLUDED)

source/mijin/util/winundef.hpp

@@ -26,7 +26,3 @@
 #if defined(DEBUG)
 #undef DEBUG
 #endif
-
-#if defined(VOID)
-#undef VOID
-#endif

source/mijin/virtual_filesystem/filesystem.cpp

@@ -3,10 +3,6 @@
 
 #include "../platform/folders.hpp"
 
-#include <filesystem>
-
-namespace fs = std::filesystem;
-
 namespace mijin
 {
 
@@ -30,91 +26,100 @@ 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
 //
 
-std::vector<FolderEntry> OSFileSystemAdapter::listFiles(PathView folder)
+fs::path OSFileSystemAdapter::getHomeFolder()
 {
-    std::vector<FolderEntry> entries;
-    std::error_code err;
+    return getKnownFolder(KnownFolder::USER_HOME);
+}
 
-    const fs::path stlFolder(folder.stringView());
-    const fs::directory_iterator iterator(stlFolder, fs::directory_options::skip_permission_denied, err);
+std::vector<FileInfo> OSFileSystemAdapter::listFiles(const fs::path& folder)
+{
+    std::vector<FileInfo> entries;
+    std::error_code err;
+    const fs::directory_iterator iterator(folder, fs::directory_options::skip_permission_denied, err);
     if (err) {
         return {}; // TODO: propagate?
     }
-    for (const fs::directory_entry& stlEntry : iterator)
+    for (const fs::directory_entry& entry : iterator)
     {
-        FolderEntry& entry = entries.emplace_back();
-        entry.path = stlEntry.path().generic_string();
-        entry.info.exists = true;
-        doGetFileInfo(stlEntry.path(), entry.info);
+        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;
+            }
+        }
     }
     return entries;
 }
 
-FileInfo OSFileSystemAdapter::getFileInfo(PathView file)
+FileInfo OSFileSystemAdapter::getFileInfo(const fs::path& file)
 {
-    const fs::path stlFile(file.stringView());
-
     FileInfo info = {};
     std::error_code err;
-    info.exists = fs::exists(stlFile, err);
+    info.path = file;
+    info.exists = fs::exists(file, err);
     if (info.exists)
     {
-        doGetFileInfo(fs::path(file.stringView()), info);
+        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;
+            }
+        }
     }
     return info;
 }
 
-Optional<NativePath> OSFileSystemAdapter::getNativePath(PathView file)
+Optional<fs::path> OSFileSystemAdapter::getNativePath(const fs::path& file)
 {
-    return NativePath(file);
+    return file;
 }
 
-StreamError OSFileSystemAdapter::open(PathView path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
+StreamError OSFileSystemAdapter::open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
 {
-    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';
-
+    const std::string pathStr = path.string();
     auto stream = std::make_unique<FileStream>();
-    const StreamError error = stream->open(pathStr, mode);
+    const StreamError error = stream->open(pathStr.c_str(), mode);
     if (error != StreamError::SUCCESS) {
         return error;
     }

source/mijin/virtual_filesystem/filesystem.hpp

@@ -6,15 +6,17 @@
 
 #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
 {
 
@@ -32,6 +34,7 @@ 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;
@@ -41,23 +44,17 @@ 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;
-    Path path_ = {};
+    fs::path path_ = {};
 public:
     PathReference() = default;
     PathReference(const PathReference&) = default;
     PathReference(PathReference&&) = default;
-    PathReference(class FileSystemAdapter* adapter, Path path) MIJIN_NOEXCEPT : adapter_(adapter), path_(std::move(path)) {}
+    PathReference(class FileSystemAdapter* adapter, fs::path path) MIJIN_NOEXCEPT : adapter_(adapter), path_(std::move(path)) {}
 
     PathReference& operator=(const PathReference&) = default;
     PathReference& operator=(PathReference&&) MIJIN_NOEXCEPT = default;
@@ -66,13 +63,13 @@ public:
 
     [[nodiscard]] bool empty() const MIJIN_NOEXCEPT { return adapter_ == nullptr; }
     [[nodiscard]] class FileSystemAdapter* getAdapter() const noexcept { return adapter_; }
-    [[nodiscard]] const Path& getPath() const MIJIN_NOEXCEPT { return path_; }
+    [[nodiscard]] const fs::path& getPath() const MIJIN_NOEXCEPT { return path_; }
     [[nodiscard]] inline FileInfo getInfo() const;
-    [[nodiscard]] inline Optional<NativePath> getNativePath() const;
+    [[nodiscard]] inline Optional<fs::path> getNativePath() const;
     [[nodiscard]] inline StreamError open(FileOpenMode mode, std::unique_ptr<Stream>& outStream) const;
 
     [[nodiscard]]
-    PathReference operator/(const Path& more) const
+    PathReference operator/(const fs::path& more) const
     {
         return PathReference(adapter_, path_ / more);
     }
@@ -83,14 +80,16 @@ class FileSystemAdapter
 public:
     virtual ~FileSystemAdapter() = default;
 
-    [[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))); }
+    [[deprecated("Will be removed ASAP, use getKnownFolder(KnownFolder::USER_HOME) from platform/folders.hpp instead.")]]
+    [[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]] PathReference getPath(Path path) MIJIN_NOEXCEPT { return PathReference(this, std::move(path)); }
-    [[nodiscard]] std::vector<PathReference> getAllPaths(PathView path)
+    [[nodiscard]] PathReference getPath(fs::path path) MIJIN_NOEXCEPT { return PathReference(this, std::move(path)); }
+    [[nodiscard]] std::vector<PathReference> getAllPaths(const fs::path& path)
     {
         std::vector<PathReference> paths;
         getAllPaths(path, paths);
@@ -101,10 +100,11 @@ public:
 class OSFileSystemAdapter : public FileSystemAdapter
 {
 public:
-    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;
+    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;
 
     static OSFileSystemAdapter& getInstance();
 };
@@ -118,7 +118,7 @@ inline FileInfo PathReference::getInfo() const
     return adapter_->getFileInfo(path_);
 }
 
-Optional<NativePath> PathReference::getNativePath() const
+Optional<fs::path> PathReference::getNativePath() const
 {
     return adapter_->getNativePath(path_);
 }

source/mijin/virtual_filesystem/memory.cpp

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

source/mijin/virtual_filesystem/memory.hpp

@@ -35,20 +35,20 @@ private:
     detail::MemoryFolder root_;
     std::vector<std::vector<std::uint8_t>> fileData_;
 public:
-    [[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;
+    [[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;
 
-    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)
+    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)
     {
         return addFile(path, data, Overwrite::NO, copyData);
     }
-    void addFolder(PathView path);
+    void addFolder(const fs::path& path);
 private:
-    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;
+    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;
 };
 } // namespace mijin
 

source/mijin/virtual_filesystem/relative.hpp

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

source/mijin/virtual_filesystem/stacked.cpp

@@ -31,20 +31,40 @@ namespace mijin
 // public functions
 //
 
-std::vector<FolderEntry> StackedFileSystemAdapter::listFiles(PathView folder)
+fs::path StackedFileSystemAdapter::getHomeFolder()
 {
-    std::vector<FolderEntry> files;
+    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;
 
     for (auto& adapter : adapters_)
     {
-        for (const FolderEntry& entry : adapter->listFiles(folder))
+        for (const FileInfo& file : adapter->listFiles(folder))
         {
-            auto it = std::ranges::find_if(files, [&](const FolderEntry& existing)
+            auto it = std::find_if(files.begin(), files.end(), [&](const FileInfo& existing)
             {
-                return existing.path == entry.path;
+                return existing.path == file.path;
             });
             if (it == files.end()) {
-                files.push_back(entry);
+                files.push_back(file);
             }
         }
     }
@@ -52,7 +72,7 @@ std::vector<FolderEntry> StackedFileSystemAdapter::listFiles(PathView folder)
     return files;
 }
 
-FileInfo StackedFileSystemAdapter::getFileInfo(PathView file)
+FileInfo StackedFileSystemAdapter::getFileInfo(const fs::path& file)
 {
     for (auto& adapter : adapters_)
     {
@@ -65,11 +85,11 @@ FileInfo StackedFileSystemAdapter::getFileInfo(PathView file)
     return {};
 }
 
-Optional<NativePath> StackedFileSystemAdapter::getNativePath(PathView file)
+Optional<fs::path> StackedFileSystemAdapter::getNativePath(const fs::path& file)
 {
     for (auto& adapter : adapters_)
     {
-        Optional<NativePath> result = adapter->getNativePath(file);
+        Optional<fs::path> result = adapter->getNativePath(file);
         if (!result.empty())
         {
             return result;
@@ -78,7 +98,7 @@ Optional<NativePath> StackedFileSystemAdapter::getNativePath(PathView file)
     return NULL_OPTIONAL;
 }
 
-StreamError StackedFileSystemAdapter::open(PathView path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
+StreamError StackedFileSystemAdapter::open(const fs::path& path, FileOpenMode mode, std::unique_ptr<Stream>& outStream)
 {
     // try to open existing files first
     for (auto& adapter : adapters_)
@@ -105,7 +125,7 @@ StreamError StackedFileSystemAdapter::open(PathView path, FileOpenMode mode, std
     return StreamError::IO_ERROR;
 }
 
-void StackedFileSystemAdapter::getAllPaths(PathView path, std::vector<PathReference>& outPaths)
+void StackedFileSystemAdapter::getAllPaths(const fs::path& path, std::vector<PathReference>& outPaths)
 {
     for (auto& adapter : adapters_)
     {

source/mijin/virtual_filesystem/stacked.hpp

@@ -28,11 +28,12 @@ class StackedFileSystemAdapter : public FileSystemAdapter
 private:
     std::vector<std::unique_ptr<FileSystemAdapter>> adapters_;
 public:
-    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;
+    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;
     using FileSystemAdapter::getAllPaths;
 
     inline FileSystemAdapter* addAdapter(std::unique_ptr<FileSystemAdapter>&& adapter) {