UnorderedMap.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Core/HashTable.h>
 
JPH_NAMESPACE_BEGIN
 
template <class Key, class Value>
class UnorderedMapDetail
{
public:
    static const Key &          sGetKey(const std::pair<Key, Value> &inKeyValue)
    {
        return inKeyValue.first;
    }
};
 
template <class Key, class Value, class Hash = JPH::Hash<Key>, class KeyEqual = std::equal_to<Key>>
class UnorderedMap : public HashTable<Key, std::pair<Key, Value>, UnorderedMapDetail<Key, Value>, Hash, KeyEqual>
{
    using Base = HashTable<Key, std::pair<Key, Value>, UnorderedMapDetail<Key, Value>, Hash, KeyEqual>;
 
public:
    using size_type = typename Base::size_type;
    using iterator = typename Base::iterator;
    using const_iterator = typename Base::const_iterator;
    using value_type = typename Base::value_type;
 
    Value &                     operator [] (const Key &inKey)
    {
        size_type index;
        bool inserted = this->InsertKey(inKey, index);
        value_type &key_value = this->GetElement(index);
        if (inserted)
            ::new (&key_value) value_type(inKey, Value());
        return key_value.second;
    }
 
    template<class... Args>
    std::pair<iterator, bool>   try_emplace(const Key &inKey, Args &&...inArgs)
    {
        size_type index;
        bool inserted = this->InsertKey(inKey, index);
        if (inserted)
            ::new (&this->GetElement(index)) value_type(std::piecewise_construct, std::forward_as_tuple(inKey), std::forward_as_tuple(std::forward<Args>(inArgs)...));
        return std::make_pair(iterator(this, index), inserted);
    }
 
    template<class... Args>
    std::pair<iterator, bool>   try_emplace(Key &&inKey, Args &&...inArgs)
    {
        size_type index;
        bool inserted = this->InsertKey(inKey, index);
        if (inserted)
            ::new (&this->GetElement(index)) value_type(std::piecewise_construct, std::forward_as_tuple(std::move(inKey)), std::forward_as_tuple(std::forward<Args>(inArgs)...));
        return std::make_pair(iterator(this, index), inserted);
    }
 
    using Base::find;
 
    iterator                    find(const Key &inKey)
    {
        const_iterator it = Base::find(inKey);
        return iterator(this, it.mIndex);
    }
};
 
JPH_NAMESPACE_END