AssetPath.h

#pragma once
#include <filesystem>
#include <functional>
 
namespace Asset {
    struct Path {
        Path() = default;

        Path(const std::filesystem::path& path);

        Path(std::filesystem::path&& path) noexcept;

        [[nodiscard]] const std::filesystem::path& fsPath() const { return filePath; }

        [[nodiscard]] const std::filesystem::path& getFilePath() const { return filePath; }

        [[nodiscard]] std::string string() const { return filePath.string(); }

        [[nodiscard]] bool empty() const { return filePath.empty(); }

        [[nodiscard]] std::size_t hash() const noexcept;

        operator const std::filesystem::path&() const { return filePath; }

        bool operator==(const Path& other) const { return filePath == other.filePath; }

        void reset();
 
    private:
        std::filesystem::path filePath = "";
    };

    struct MeshPath {
        MeshPath() = default;

        MeshPath(const std::filesystem::path& path, const std::string& assetName);

        MeshPath(MeshPath&& other ) noexcept;

        MeshPath( const MeshPath & other) noexcept;

        MeshPath& operator=(const MeshPath&) = default;

        MeshPath& operator=(MeshPath&&) noexcept = default;

        [[nodiscard]] const std::filesystem::path& getFilePath() const { return filePath_; }

        [[nodiscard]] const std::string& getAssetName() const { return assetName_; }

        [[nodiscard]] std::string getAssetHandle() const { return filePath_.string() + assetName_; }

        [[nodiscard]] std::size_t hash() const noexcept;

        [[nodiscard]] bool empty() const { return filePath_.empty() || assetName_.empty(); }

        bool operator==(const MeshPath& other) const {
            return filePath_ == other.filePath_ && assetName_ == other.assetName_;
        }

        void reset();
 
    private:
        std::filesystem::path filePath_ = "";
        std::string assetName_ = std::string("");
    };
}
 
namespace std {
    template<>
    struct hash<Asset::Path> {
        size_t operator()(const Asset::Path& path) const noexcept {
            return path.hash();
        }
    };

    template<>
    struct hash<Asset::MeshPath> {
        size_t operator()(const Asset::MeshPath& path) const noexcept {
            return path.hash();
        }
    };
}