filesystem.h

#pragma once
 
#include "pixelbullet/filesystem/asset_path.h"
#include "pixelbullet/filesystem/virtual_path.h"
 
#include <filesystem>
#include <functional>
#include <optional>
#include <string>
#include <string_view>
 
namespace pixelbullet
{
namespace filesystem_internal
{
class FilesystemRuntimeAccess;
}
 
class Filesystem
{
public:
    static constexpr std::string_view assets_alias = "assets";
    static constexpr std::string_view shared_alias = "shared";
 
    struct Config
    {
        std::string workspace = "pixelbullet";
        std::filesystem::path asset_base_path;
        std::filesystem::path workspace_root;
        std::filesystem::path packaged_runtime_root;
    };
 
    Filesystem();
    explicit Filesystem(Config config);
    ~Filesystem() = default;
 
    Filesystem(const Filesystem&) = delete;
    Filesystem& operator=(const Filesystem&) = delete;
    Filesystem(Filesystem&&) = delete;
    Filesystem& operator=(Filesystem&&) = delete;
 
    [[nodiscard]] std::optional<std::filesystem::path> try_resolve(const VirtualPath& path) const;
    [[nodiscard]] std::optional<std::filesystem::path> try_resolve(const AssetPath& path) const;
    [[nodiscard]] std::filesystem::path resolve(const VirtualPath& path) const;
    [[nodiscard]] std::filesystem::path resolve(const AssetPath& path) const;
    [[nodiscard]] std::filesystem::path resolve_writable(const VirtualPath& path) const;
    [[nodiscard]] std::filesystem::path resolve_writable(const AssetPath& path) const;
    [[nodiscard]] bool exists(const VirtualPath& path) const;
    [[nodiscard]] bool exists(const AssetPath& path) const;
 
    [[nodiscard]] const std::filesystem::path& asset_base_path() const noexcept
    {
        return asset_base_path_;
    }
 
    [[nodiscard]] const std::filesystem::path& workspace_root() const noexcept
    {
        return workspace_root_;
    }
 
    [[nodiscard]] const std::filesystem::path& packaged_runtime_root() const noexcept
    {
        return packaged_runtime_root_;
    }
 
private:
    using RuntimeLookup = std::function<std::optional<std::filesystem::path>(const std::filesystem::path&)>;
    friend class filesystem_internal::FilesystemRuntimeAccess;
 
    explicit Filesystem(Config config, RuntimeLookup runtime_lookup);
 
    enum class VirtualRoot
    {
        Direct,
        Assets,
        Shared,
    };
 
    struct ExpandedPath
    {
        std::filesystem::path path;
        VirtualRoot root = VirtualRoot::Direct;
    };
 
    [[nodiscard]] std::optional<ExpandedPath> expand_path(const VirtualPath& path) const;
    [[nodiscard]] std::filesystem::path build_runtime_relative_path(const std::filesystem::path& logical_path, VirtualRoot root) const;
    [[nodiscard]] std::filesystem::path build_runtime_lookup_path(const std::filesystem::path& logical_path, VirtualRoot root) const;
    [[nodiscard]] std::filesystem::path build_packaged_lookup(const std::filesystem::path& logical_path, VirtualRoot root) const;
    [[nodiscard]] static std::filesystem::path detect_workspace_root(const std::filesystem::path& start_path);
 
private:
    RuntimeLookup runtime_lookup_;
    std::string workspace_name_;
    std::filesystem::path asset_base_path_;
    std::filesystem::path workspace_root_;
    std::filesystem::path packaged_runtime_root_;
};
} // namespace pixelbullet