SmallFlatMap.hpp

Go to the documentation of this file.

#pragma once
 
#include "CeresEngine/Foundation/Allocator.hpp"
#include "CeresEngine/Foundation/Hash.hpp"
 
#include <sfl/small_flat_map.hpp>
#include <sfl/small_flat_multimap.hpp>
#include <sfl/small_unordered_flat_map.hpp>
#include <sfl/small_unordered_flat_multimap.hpp>
 
namespace CeresEngine {
 
    template<typename Key, typename T, std::size_t N, typename Compare = std::less<>, typename RawAllocator = DefaultAllocator>
    using SmallFlatMap = sfl::small_flat_map<Key, T, N, Compare, StdAllocator<std::pair<Key, T>, RawAllocator>>;
 
    template<typename Key, typename T, std::size_t N, typename Compare = std::less<>, typename RawAllocator = DefaultAllocator>
    using SmallFlatMultimap = sfl::small_flat_multimap<Key, T, N, Compare, StdAllocator<std::pair<Key, T>, RawAllocator>>;
 
    template<typename Key, typename T, std::size_t N, typename KeyEqual = std::equal_to<>, typename RawAllocator = DefaultAllocator>
    using SmallUnorderedFlatMap = sfl::small_unordered_flat_map<Key, T, N, KeyEqual, StdAllocator<std::pair<Key, T>, RawAllocator>>;
 
    template<typename Key, typename T, std::size_t N, typename KeyEqual = std::equal_to<>, typename RawAllocator = DefaultAllocator>
    using SmallUnorderedFlatMultimap = sfl::small_unordered_flat_multimap<Key, T, N, KeyEqual, StdAllocator<std::pair<Key, T>, RawAllocator>>;
 
} // namespace CeresEngine
 
template<typename Key, typename T, std::size_t N, typename Compare, typename RawAllocator>
struct std::hash<CeresEngine::SmallFlatMap<Key, T, N, Compare, RawAllocator>> {
    using ValueType = CeresEngine::SmallFlatMap<Key, T, N, Compare, RawAllocator>;
 
    [[nodiscard]] size_t operator()(const ValueType& value) {
        size_t hash = 0;
        for(const auto& entry : value) {
            CeresEngine::combine(hash, entry);
        }
        return hash;
    }
};
 
template<typename Key, typename T, std::size_t N, typename Compare, typename RawAllocator>
struct std::hash<CeresEngine::SmallFlatMultimap<Key, T, N, Compare, RawAllocator>> {
    using ValueType = CeresEngine::SmallFlatMultimap<Key, T, N, Compare, RawAllocator>;
 
    [[nodiscard]] size_t operator()(const ValueType& value) {
        size_t hash = 0;
        for(const auto& entry : value) {
            CeresEngine::combine(hash, entry);
        }
        return hash;
    }
};
 
template<typename Key, typename T, std::size_t N, typename KeyEqual, typename RawAllocator>
struct std::hash<CeresEngine::SmallUnorderedFlatMap<Key, T, N, KeyEqual, RawAllocator>> {
    using ValueType = CeresEngine::SmallUnorderedFlatMap<Key, T, N, KeyEqual, RawAllocator>;
 
    [[nodiscard]] size_t operator()(const ValueType& value) {
        size_t hash = 0;
        for(const auto& entry : value) {
            CeresEngine::combine(hash, entry);
        }
        return hash;
    }
};
 
template<typename Key, typename T, std::size_t N, typename KeyEqual, typename RawAllocator>
struct std::hash<CeresEngine::SmallUnorderedFlatMultimap<Key, T, N, KeyEqual, RawAllocator>> {
    using ValueType = CeresEngine::SmallUnorderedFlatMultimap<Key, T, N, KeyEqual, RawAllocator>;
 
    [[nodiscard]] size_t operator()(const ValueType& value) {
        size_t hash = 0;
        for(const auto& entry : value) {
            CeresEngine::combine(hash, entry);
        }
        return hash;
    }
};