AssetPath.h

Go to the documentation of this file.

#pragma once
#include <filesystem>
#include <functional>
 
namespace Asset {
    struct Path {
        Path() = default;
        Path(const std::filesystem::path& path, const std::string& assetName);
 
        // constructors
        Path(Path&& other ) noexcept;
        Path( const Path & other) noexcept;
 
        // assignment
        Path& operator=(const Path&) = default;
        Path& operator=(Path&&) 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 Path& other) const {
            return filePath == other.filePath && assetName == other.assetName;
        }
 
        void reset();
 
    private:
        std::filesystem::path filePath = "";
        std::string assetName = std::string("");
    };
 
    inline Path::Path(const std::filesystem::path &path, const std::string &assetName) : filePath(path), assetName(assetName) {
    }
 
    inline Path::Path( Path && other ) noexcept : filePath(std::move(other.filePath)), assetName(std::move(other.assetName))
    {
    }
 
    inline Path::Path( const Path & other ) noexcept : filePath(other.filePath), assetName(other.assetName)
    {
    }
 
    inline std::size_t Path::hash() const noexcept
    {
        const std::size_t pathHash = std::filesystem::hash_value(filePath);
        const std::size_t nameHash = std::hash<std::string>{}(assetName);
        return pathHash ^ (nameHash + 0x9e3779b9 + (pathHash << 6) + (pathHash >> 2));
    }
 
    inline void Path::reset()
    {
        filePath = std::filesystem::path("");
        assetName = std::string("");
    }
 
    static Path GetTexturePath(const std::filesystem::path& path) {
        return {path, path.filename().generic_string()};
    }
}
 
namespace std {
    template<>
    struct hash<Asset::Path> {
        size_t operator()(const Asset::Path& path) const noexcept {
            return path.hash();
        }
    };
}