AudioFlow.h

#pragma once
 
#include <cstdint>
#include <filesystem>
#include <string>
 
namespace Engine::Assets {

    struct AudioFlowHandle {
        std::filesystem::path path;   
        std::string           name;   
 
        [[nodiscard]] bool isValid() const noexcept { return !name.empty(); }
        explicit operator bool() const noexcept { return isValid(); }
 
        friend bool operator==( const AudioFlowHandle& a, const AudioFlowHandle& b ) noexcept
        {
            return a.path == b.path && a.name == b.name;
        }
        friend bool operator!=( const AudioFlowHandle& a, const AudioFlowHandle& b ) noexcept
        {
            return !( a == b );
        }
    };

    struct FlowSettingHandle {
        AudioFlowHandle flow;
        uint32_t        settingIndex = 0;  
        uint32_t        generation   = 0;  
 
        [[nodiscard]] bool isValid() const noexcept { return flow.isValid(); }
        explicit operator bool() const noexcept { return isValid(); }
 
        friend bool operator==( const FlowSettingHandle& a, const FlowSettingHandle& b ) noexcept
        {
            return a.flow == b.flow && a.settingIndex == b.settingIndex && a.generation == b.generation;
        }
        friend bool operator!=( const FlowSettingHandle& a, const FlowSettingHandle& b ) noexcept
        {
            return !( a == b );
        }
    };
 
}  // namespace Engine::Assets
 
namespace std {
    template<>
    struct hash<Engine::Assets::AudioFlowHandle>
    {
        size_t operator()( const Engine::Assets::AudioFlowHandle& handle ) const noexcept
        {
            const size_t pathHash = hash<std::filesystem::path>{}( handle.path );
            const size_t nameHash = hash<std::string>{}( handle.name );
            return pathHash ^ ( nameHash + 0x9e3779b9u + ( pathHash << 6 ) + ( pathHash >> 2 ) );
        }
    };
}  // namespace std