asset_path.h

#pragma once
 
#include "pixelbullet/core/assert.h"
#include "pixelbullet/filesystem/virtual_path.h"
 
#include <cstddef>
#include <optional>
#include <string>
#include <string_view>
 
namespace pixelbullet::filesystem
{
struct ParsedAssetAliasPath
{
    std::string_view alias;
    std::string_view remainder;
};
 
[[nodiscard]] bool is_known_asset_alias(std::string_view alias) noexcept;
[[nodiscard]] bool is_valid_asset_alias_remainder(std::string_view remainder);
[[nodiscard]] std::optional<ParsedAssetAliasPath> parse_asset_alias_path(std::string_view logical_path);
[[nodiscard]] bool is_valid_asset_logical_path(std::string_view logical_path);
} // namespace pixelbullet::filesystem
 
namespace pixelbullet
{
class AssetPath
{
public:
    AssetPath() = default;
 
    AssetPath(std::string_view path)
    {
        AssignTrusted(path);
    }
 
    AssetPath(const char* path)
        : AssetPath(std::string_view(path ? path : ""))
    {
    }
 
    AssetPath(const std::string& path)
        : AssetPath(std::string_view(path))
    {
    }
 
    AssetPath(const VirtualPath& path)
        : AssetPath(path.logical_path())
    {
    }
 
    [[nodiscard]] static bool IsValid(std::string_view path)
    {
        return filesystem::is_valid_asset_logical_path(path);
    }
 
    [[nodiscard]] static std::optional<AssetPath> TryCreate(std::string_view path)
    {
        if (!IsValid(path))
        {
            return std::nullopt;
        }
 
        return AssetPath(path, TrustedTag{});
    }
 
    [[nodiscard]] const char* c_str() const noexcept
    {
        return logical_path_.c_str();
    }
 
    [[nodiscard]] const std::string& logical_path() const noexcept
    {
        return logical_path_;
    }
 
    [[nodiscard]] bool empty() const noexcept
    {
        return logical_path_.empty();
    }
 
    [[nodiscard]] std::string_view extension() const noexcept
    {
        const std::size_t last_forward_slash = logical_path_.rfind('/');
        const std::size_t segment_start = last_forward_slash == std::string::npos ? 0u : last_forward_slash + 1u;
        const std::size_t dot_position = logical_path_.rfind('.');
        if (dot_position != std::string::npos && dot_position >= segment_start)
        {
            return std::string_view(logical_path_).substr(dot_position);
        }
        return std::string_view{};
    }
 
    [[nodiscard]] bool has_extension(const std::string_view ext) const noexcept
    {
        return extension() == ext;
    }
 
    [[nodiscard]] VirtualPath AsVirtualPath() const
    {
        return VirtualPath(logical_path_);
    }
 
    [[nodiscard]] operator VirtualPath() const
    {
        return AsVirtualPath();
    }
 
private:
    struct TrustedTag
    {
    };
 
    AssetPath(std::string_view path, TrustedTag)
        : logical_path_(path)
    {
    }
 
    void AssignTrusted(std::string_view path)
    {
        ASSERT(IsValid(path), "Invalid authored asset path '{}'", path);
        logical_path_ = path;
    }
 
private:
    std::string logical_path_;
};
 
[[nodiscard]] inline bool operator==(const AssetPath& lhs, const AssetPath& rhs) noexcept
{
    return lhs.logical_path() == rhs.logical_path();
}
 
[[nodiscard]] inline bool operator!=(const AssetPath& lhs, const AssetPath& rhs) noexcept
{
    return !(lhs == rhs);
}
 
[[nodiscard]] inline bool operator==(const AssetPath& lhs, const VirtualPath& rhs) noexcept
{
    return lhs.logical_path() == rhs.logical_path();
}
 
[[nodiscard]] inline bool operator==(const VirtualPath& lhs, const AssetPath& rhs) noexcept
{
    return lhs.logical_path() == rhs.logical_path();
}
 
[[nodiscard]] inline bool operator!=(const AssetPath& lhs, const VirtualPath& rhs) noexcept
{
    return !(lhs == rhs);
}
 
[[nodiscard]] inline bool operator!=(const VirtualPath& lhs, const AssetPath& rhs) noexcept
{
    return !(lhs == rhs);
}
 
[[nodiscard]] inline AssetPath operator/(const AssetPath& lhs, const std::string_view rhs)
{
    std::string result = lhs.logical_path();
    if (!result.empty() && result.back() != '/' && !rhs.empty() && rhs.front() != '/')
    {
        result += '/';
    }
    result += rhs;
    return AssetPath(result);
}
 
[[nodiscard]] inline AssetPath operator/(const AssetPath& lhs, const char* rhs)
{
    return lhs / std::string_view(rhs ? rhs : "");
}
} // namespace pixelbullet