virtual_path.h

#pragma once
 
#include <cstddef>
#include <string>
#include <string_view>
 
namespace pixelbullet
{
class VirtualPath
{
public:
    VirtualPath() = default;
 
    explicit VirtualPath(std::string_view path)
        : logical_path_(path)
    {
    }
 
    explicit VirtualPath(const char* path)
        : logical_path_(path ? path : "")
    {
    }
 
    VirtualPath(const VirtualPath&) = default;
    VirtualPath(VirtualPath&&) noexcept = default;
 
    VirtualPath& operator=(const VirtualPath&) = default;
    VirtualPath& operator=(VirtualPath&&) noexcept = default;
 
    ~VirtualPath() = default;
 
    [[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::wstring to_wstring() const
    {
        return std::wstring(logical_path_.begin(), logical_path_.end());
    }
 
    [[nodiscard]] bool has_extension(std::string_view ext) const noexcept
    {
        return extension() == ext;
    }
 
    [[nodiscard]] std::string_view extension() const noexcept
    {
        const std::size_t last_forward_slash = logical_path_.rfind('/');
        const std::size_t last_backslash = logical_path_.rfind('\\');
        const std::size_t last_separator = last_forward_slash == std::string::npos ? last_backslash
                                           : last_backslash == std::string::npos
                                               ? last_forward_slash
                                               : (last_forward_slash > last_backslash ? last_forward_slash : last_backslash);
        const std::size_t segment_start = last_separator == std::string::npos ? 0u : last_separator + 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{};
    }
 
private:
    std::string logical_path_;
};
 
inline VirtualPath operator/(const VirtualPath& lhs, const std::string& rhs)
{
    std::string result = lhs.logical_path();
    if (!result.empty() && result.back() != '/' && !rhs.empty() && rhs.front() != '/')
    {
        result += '/';
    }
    result += rhs;
    return VirtualPath(result);
}
 
inline VirtualPath operator/(const VirtualPath& lhs, const char* rhs)
{
    return lhs / std::string(rhs);
}
 
inline bool operator==(const VirtualPath& lhs, const VirtualPath& rhs) noexcept
{
    return lhs.logical_path() == rhs.logical_path();
}
 
inline bool operator!=(const VirtualPath& lhs, const VirtualPath& rhs) noexcept
{
    return !(lhs == rhs);
}
 
inline VirtualPath operator""_vp(const char* str, std::size_t len)
{
    return VirtualPath(std::string_view(str, len));
}
} // namespace pixelbullet