virtual_path.h

#pragma once
 
#include <cstddef>
#include <string>
#include <string_view>
 
namespace pixelbullet
{
class VirtualPath
{
public:
    VirtualPath() = default;
 
    VirtualPath(std::string_view path)
        : logical_path_(path)
    {
    }
 
    VirtualPath(const char* path)
        : logical_path_(path)
    {
    }
 
    VirtualPath(const VirtualPath&) = default;
    VirtualPath(VirtualPath&&) noexcept = default;
 
    VirtualPath& operator=(const VirtualPath&) = default;
    VirtualPath& operator=(VirtualPath&&) noexcept = default;
 
    ~VirtualPath() = default;
 
    operator std::string() const
    {
        return logical_path_;
    }
    operator std::string_view() const noexcept
    {
        return logical_path_;
    }
    const char* CString() const noexcept
    {
        return logical_path_.c_str();
    }
 
    [[nodiscard]] const std::string& LogicalPath() const noexcept
    {
        return logical_path_;
    }
 
    [[nodiscard]] bool Empty() const noexcept
    {
        return logical_path_.empty();
    }
 
    [[nodiscard]] std::wstring ToWString() const
    {
        return std::wstring(logical_path_.begin(), logical_path_.end());
    }
 
    [[nodiscard]] bool HasExtension(std::string_view ext) const noexcept
    {
        return Extension() == ext;
    }
 
    [[nodiscard]] std::string_view Extension() const noexcept
    {
        const std::size_t pos = logical_path_.rfind('.');
        if (pos != std::string::npos)
        {
            return std::string_view(logical_path_).substr(pos);
        }
        return std::string_view{};
    }
 
private:
    std::string logical_path_;
};
 
inline VirtualPath operator/(const VirtualPath& lhs, const std::string& rhs)
{
    std::string result = lhs.LogicalPath();
    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 VirtualPath operator"" _vp(const char* str, size_t len)
{
    return VirtualPath(std::string_view(str, len));
}
} // namespace pixelbullet