VirtualPath.hpp

#pragma once
 
#include "PixelBullet/Serialization/Node.hpp"
 
#include <string>
#include <string_view>
 
namespace PixelBullet
{
    class VirtualPath
    {
    public:
        VirtualPath() = default;
 
        VirtualPath(std::string_view path)
            : m_LogicalPath(path)
        {
        }
 
        VirtualPath(const char* path)
            : m_LogicalPath(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 GetResolved();
        }
        operator std::string_view() const noexcept
        {
            return GetResolved();
        }
        const char* c_str() const noexcept
        {
            return GetResolved().c_str();
        }
 
        [[nodiscard]] const std::string& LogicalPath() const noexcept
        {
            return m_LogicalPath;
        }
 
        [[nodiscard]] const std::string& GetResolved() const
        {
            if (!m_ResolvedComputed)
            {
                m_CachedResolved = Resolve();
                m_ResolvedComputed = true;
            }
            return m_CachedResolved;
        }
 
        [[nodiscard]] std::string_view GetResolvedView() const noexcept
        {
            return GetResolved();
        }
 
        [[nodiscard]] std::wstring ToWString() const
        {
            const auto& resolved = GetResolved();
            return std::wstring(resolved.begin(), resolved.end());
        }
 
        [[nodiscard]] bool HasExtension(std::string_view ext) const noexcept
        {
            return extension() == ext;
        }
 
        [[nodiscard]] std::string_view extension() const noexcept
        {
            const auto& resolved = GetResolved();
            size_t pos = resolved.rfind('.');
            if (pos != std::string::npos)
            {
                return std::string_view(resolved).substr(pos);
            }
            return std::string_view{};
        }
 
        std::string Resolve() const;
 
    private:
        std::string m_LogicalPath;
        mutable bool m_ResolvedComputed = false;
        mutable std::string m_CachedResolved;
    };
 
    inline VirtualPath operator/(const VirtualPath& lhs, const std::string& rhs)
    {
        std::string result = lhs.GetResolved();
        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));
    }
 
    inline const Node& operator>>(const Node& node, VirtualPath& path)
    {
        path = VirtualPath(node.GetValue());
        return node;
    }
 
    inline Node& operator<<(Node& node, const VirtualPath& path)
    {
        node.SetValue(path.LogicalPath());
        node.SetType(NodeType::String);
        return node;
    }
} // namespace PixelBullet