unordered_multimap.h

Go to the documentation of this file.

/**********************************************************\
 
  This file is part of the
  https://github.com/morzhovets/momo
  project, distributed under the MIT License. See
  https://github.com/morzhovets/momo/blob/branch_cpp11/LICENSE
  for details.
 
  momo/stdish/unordered_multimap.h
 
  namespace momo::stdish:
    class unordered_multimap_adaptor
    class unordered_multimap
    class unordered_multimap_open
 
\**********************************************************/
 
#ifndef MOMO_INCLUDE_GUARD_STDISH_UNORDERED_MULTIMAP
#define MOMO_INCLUDE_GUARD_STDISH_UNORDERED_MULTIMAP
 
#include "set_map_utility.h"
#include MOMO_PARENT_HEADER(HashMultiMap)
 
namespace momo
{
 
namespace stdish
{
 
template<typename THashMultiMap>
class unordered_multimap_adaptor
{
private:
    typedef THashMultiMap HashMultiMap;
    typedef typename HashMultiMap::HashTraits HashTraits;
    typedef typename HashMultiMap::MemManager MemManager;
 
public:
    typedef typename HashMultiMap::Key key_type;
    typedef typename HashMultiMap::Value mapped_type;
    typedef typename HashTraits::Hasher hasher;
    typedef typename HashTraits::EqualComparer key_equal;
 
    typedef HashMultiMap nested_container_type;
 
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
 
    typedef std::pair<const key_type, mapped_type> value_type;
    typedef typename std::allocator_traits<typename MemManager::ByteAllocator>
        ::template rebind_alloc<value_type> allocator_type;
 
    typedef momo::internal::HashDerivedIterator<typename HashMultiMap::Iterator,
        momo::internal::MapReferenceStd> iterator;
    typedef typename iterator::ConstIterator const_iterator;
 
    typedef typename iterator::Reference reference;
    typedef typename const_iterator::Reference const_reference;
 
    typedef typename iterator::Pointer pointer;
    typedef typename const_iterator::Pointer const_pointer;
    //typedef typename std::allocator_traits<allocator_type>::pointer pointer;
    //typedef typename std::allocator_traits<allocator_type>::const_pointer const_pointer;
 
    //node_type;
 
    //local_iterator;
    //const_local_iterator;
 
private:
    template<typename KeyArg>
    struct IsValidKeyArg : public HashTraits::template IsValidKeyArg<KeyArg>
    {
    };
 
    struct ConstIteratorProxy : private const_iterator
    {
        typedef const_iterator ConstIterator;
        MOMO_DECLARE_PROXY_FUNCTION(ConstIterator, GetBaseIterator)
    };
 
public:
    unordered_multimap_adaptor()
    {
    }
 
    explicit unordered_multimap_adaptor(const allocator_type& alloc)
        : mHashMultiMap(HashTraits(), MemManager(alloc))
    {
    }
 
    explicit unordered_multimap_adaptor(size_type bucketCount,
        const allocator_type& alloc = allocator_type())
        : mHashMultiMap(HashTraits(bucketCount), MemManager(alloc))
    {
    }
 
    unordered_multimap_adaptor(size_type bucketCount, const hasher& hashFunc,
        const allocator_type& alloc = allocator_type())
        : mHashMultiMap(HashTraits(bucketCount, hashFunc), MemManager(alloc))
    {
    }
 
    unordered_multimap_adaptor(size_type bucketCount, const hasher& hashFunc,
        const key_equal& equalComp, const allocator_type& alloc = allocator_type())
        : mHashMultiMap(HashTraits(bucketCount, hashFunc, equalComp), MemManager(alloc))
    {
    }
 
    template<typename Iterator>
    unordered_multimap_adaptor(Iterator first, Iterator last)
    {
        insert(first, last);
    }
 
    template<typename Iterator>
    unordered_multimap_adaptor(Iterator first, Iterator last, size_type bucketCount,
        const allocator_type& alloc = allocator_type())
        : unordered_multimap_adaptor(bucketCount, alloc)
    {
        insert(first, last);
    }
 
    template<typename Iterator>
    unordered_multimap_adaptor(Iterator first, Iterator last, size_type bucketCount,
        const hasher& hashFunc, const allocator_type& alloc = allocator_type())
        : unordered_multimap_adaptor(bucketCount, hashFunc, alloc)
    {
        insert(first, last);
    }
 
    template<typename Iterator>
    unordered_multimap_adaptor(Iterator first, Iterator last, size_type bucketCount,
        const hasher& hashFunc, const key_equal& equalComp, const allocator_type& alloc = allocator_type())
        : unordered_multimap_adaptor(bucketCount, hashFunc, equalComp, alloc)
    {
        insert(first, last);
    }
 
    unordered_multimap_adaptor(std::initializer_list<value_type> values)
        : unordered_multimap_adaptor(values.begin(), values.end())
    {
    }
 
    unordered_multimap_adaptor(std::initializer_list<value_type> values, size_type bucketCount,
        const allocator_type& alloc = allocator_type())
        : unordered_multimap_adaptor(values.begin(), values.end(), bucketCount, alloc)
    {
    }
 
    unordered_multimap_adaptor(std::initializer_list<value_type> values, size_type bucketCount,
        const hasher& hashFunc, const allocator_type& alloc = allocator_type())
        : unordered_multimap_adaptor(values.begin(), values.end(), bucketCount, hashFunc, alloc)
    {
    }
 
    unordered_multimap_adaptor(std::initializer_list<value_type> values, size_type bucketCount,
        const hasher& hashFunc, const key_equal& equalComp, const allocator_type& alloc = allocator_type())
        : unordered_multimap_adaptor(values.begin(), values.end(), bucketCount, hashFunc, equalComp, alloc)
    {
    }
 
#ifdef MOMO_HAS_CONTAINERS_RANGES
    template<std::ranges::input_range Range>
    requires std::convertible_to<std::ranges::range_reference_t<Range>, value_type>
    unordered_multimap_adaptor(std::from_range_t, Range&& values)
    {
        insert_range(std::forward<Range>(values));
    }
 
    template<std::ranges::input_range Range>
    requires std::convertible_to<std::ranges::range_reference_t<Range>, value_type>
    unordered_multimap_adaptor(std::from_range_t, Range&& values, size_type bucketCount,
        const allocator_type& alloc = allocator_type())
        : unordered_multimap_adaptor(bucketCount, alloc)
    {
        insert_range(std::forward<Range>(values));
    }
 
    template<std::ranges::input_range Range>
    requires std::convertible_to<std::ranges::range_reference_t<Range>, value_type>
    unordered_multimap_adaptor(std::from_range_t, Range&& values, size_type bucketCount,
        const hasher& hashFunc, const allocator_type& alloc = allocator_type())
        : unordered_multimap_adaptor(bucketCount, hashFunc, alloc)
    {
        insert_range(std::forward<Range>(values));
    }
 
    template<std::ranges::input_range Range>
    requires std::convertible_to<std::ranges::range_reference_t<Range>, value_type>
    unordered_multimap_adaptor(std::from_range_t, Range&& values, size_type bucketCount,
        const hasher& hashFunc, const key_equal& equalComp,
        const allocator_type& alloc = allocator_type())
        : unordered_multimap_adaptor(bucketCount, hashFunc, equalComp, alloc)
    {
        insert_range(std::forward<Range>(values));
    }
#endif // MOMO_HAS_CONTAINERS_RANGES
 
    unordered_multimap_adaptor(unordered_multimap_adaptor&& right)
        : unordered_multimap_adaptor(std::move(right), right.get_allocator())
    {
    }
 
    unordered_multimap_adaptor(unordered_multimap_adaptor&& right, const allocator_type& alloc)
        : mHashMultiMap(right.mHashMultiMap.GetHashTraits(), MemManager(alloc))
    {
        if (right.get_allocator() == alloc)
        {
            mHashMultiMap.Swap(right.mHashMultiMap);
        }
        else
        {
            for (reference ref : right)
                mHashMultiMap.Add(ref.first, std::move(ref.second));
            right.clear();
        }
    }
 
    unordered_multimap_adaptor(const unordered_multimap_adaptor& right)
        : mHashMultiMap(right.mHashMultiMap)
    {
    }
 
    unordered_multimap_adaptor(const unordered_multimap_adaptor& right, const allocator_type& alloc)
        : mHashMultiMap(right.mHashMultiMap, MemManager(alloc))
    {
    }
 
    ~unordered_multimap_adaptor() = default;
 
    unordered_multimap_adaptor& operator=(unordered_multimap_adaptor&& right)
        noexcept(momo::internal::ContainerAssignerStd::IsNothrowMoveAssignable<unordered_multimap_adaptor>::value)
    {
        return momo::internal::ContainerAssignerStd::Move(std::move(right), *this);
    }
 
    unordered_multimap_adaptor& operator=(const unordered_multimap_adaptor& right)
    {
        return momo::internal::ContainerAssignerStd::Copy(right, *this);
    }
 
    unordered_multimap_adaptor& operator=(std::initializer_list<value_type> values)
    {
        mHashMultiMap = HashMultiMap(values, mHashMultiMap.GetHashTraits(), MemManager(get_allocator()));
        return *this;
    }
 
    void swap(unordered_multimap_adaptor& right) noexcept
    {
        momo::internal::ContainerAssignerStd::Swap(*this, right);
    }
 
    friend void swap(unordered_multimap_adaptor& left, unordered_multimap_adaptor& right) noexcept
    {
        left.swap(right);
    }
 
    const nested_container_type& get_nested_container() const noexcept
    {
        return mHashMultiMap;
    }
 
    nested_container_type& get_nested_container() noexcept
    {
        return mHashMultiMap;
    }
 
    const_iterator begin() const noexcept
    {
        return momo::internal::ProxyConstructor<const_iterator>(mHashMultiMap.GetBegin());
    }
 
    iterator begin() noexcept
    {
        return momo::internal::ProxyConstructor<iterator>(mHashMultiMap.GetBegin());
    }
 
    const_iterator end() const noexcept
    {
        return momo::internal::ProxyConstructor<const_iterator>(mHashMultiMap.GetEnd());
    }
 
    iterator end() noexcept
    {
        return momo::internal::ProxyConstructor<iterator>(mHashMultiMap.GetEnd());
    }
 
    const_iterator cbegin() const noexcept
    {
        return begin();
    }
 
    const_iterator cend() const noexcept
    {
        return end();
    }
 
    //float max_load_factor() const noexcept
    //void max_load_factor(float maxLoadFactor)
 
    hasher hash_function() const
    {
        return mHashMultiMap.GetHashTraits().GetHasher();
    }
 
    key_equal key_eq() const
    {
        return mHashMultiMap.GetHashTraits().GetEqualComparer();
    }
 
    allocator_type get_allocator() const noexcept
    {
        return allocator_type(mHashMultiMap.GetMemManager().GetByteAllocator());
    }
 
    size_type max_size() const noexcept
    {
        return std::allocator_traits<allocator_type>::max_size(get_allocator());
    }
 
    size_type size() const noexcept
    {
        return mHashMultiMap.GetCount();
    }
 
    MOMO_NODISCARD bool empty() const noexcept
    {
        return mHashMultiMap.IsEmpty();
    }
 
    void clear() noexcept
    {
        mHashMultiMap.Clear();
    }
 
    //void rehash(size_type bucketCount)
    //void reserve(size_type count)
 
    MOMO_FORCEINLINE const_iterator find(const key_type& key) const
    {
        return equal_range(key).first;
    }
 
    MOMO_FORCEINLINE iterator find(const key_type& key)
    {
        return equal_range(key).first;
    }
 
    template<typename KeyArg>
    MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value,
    const_iterator> find(const KeyArg& key) const
    {
        return equal_range(key).first;
    }
 
    template<typename KeyArg>
    MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value,
    iterator> find(const KeyArg& key)
    {
        return equal_range(key).first;
    }
 
    MOMO_FORCEINLINE size_type count(const key_type& key) const
    {
        typename HashMultiMap::ConstKeyIterator keyIter = mHashMultiMap.Find(key);
        return !!keyIter ? keyIter->GetCount() : 0;
    }
 
    template<typename KeyArg>
    MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value,
    size_type> count(const KeyArg& key) const
    {
        typename HashMultiMap::ConstKeyIterator keyIter = mHashMultiMap.Find(key);
        return !!keyIter ? keyIter->GetCount() : 0;
    }
 
    MOMO_FORCEINLINE bool contains(const key_type& key) const
    {
        return count(key) > 0;
    }
 
    template<typename KeyArg>
    MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value,
    bool> contains(const KeyArg& key) const
    {
        return count(key) > 0;
    }
 
    MOMO_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& key) const
    {
        return pvEqualRange<const_iterator>(mHashMultiMap, mHashMultiMap.Find(key));
    }
 
    MOMO_FORCEINLINE std::pair<iterator, iterator> equal_range(const key_type& key)
    {
        return pvEqualRange<iterator>(mHashMultiMap, mHashMultiMap.Find(key));
    }
 
    template<typename KeyArg>
    MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value,
    std::pair<const_iterator, const_iterator>> equal_range(const KeyArg& key) const
    {
        return pvEqualRange<const_iterator>(mHashMultiMap, mHashMultiMap.Find(key));
    }
 
    template<typename KeyArg>
    MOMO_FORCEINLINE momo::internal::EnableIf<IsValidKeyArg<KeyArg>::value,
    std::pair<iterator, iterator>> equal_range(const KeyArg& key)
    {
        return pvEqualRange<iterator>(mHashMultiMap, mHashMultiMap.Find(key));
    }
 
    template<typename ValueArg = std::pair<key_type, mapped_type>>
    momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value,
    iterator> insert(ValueArg&& valueArg)
    {
        return emplace(std::forward<ValueArg>(valueArg));
    }
 
    template<typename ValueArg = std::pair<key_type, mapped_type>>
    momo::internal::EnableIf<std::is_constructible<value_type, ValueArg&&>::value,
    iterator> insert(const_iterator, ValueArg&& valueArg)
    {
        return insert(std::forward<ValueArg>(valueArg));
    }
 
    template<typename Iterator>
    void insert(Iterator first, Iterator last)
    {
        pvInsertRange(first, last);
    }
 
    void insert(std::initializer_list<value_type> values)
    {
        mHashMultiMap.Add(values.begin(), values.end());
    }
 
#ifdef MOMO_HAS_CONTAINERS_RANGES
    template<std::ranges::input_range Range>
    requires std::convertible_to<std::ranges::range_reference_t<Range>, value_type>
    void insert_range(Range&& values)
    {
        pvInsertRange(std::ranges::begin(values), std::ranges::end(values));
    }
#endif // MOMO_HAS_CONTAINERS_RANGES
 
    iterator emplace()
    {
        return pvEmplace(std::tuple<>(), std::tuple<>());
    }
 
    iterator emplace_hint(const_iterator)
    {
        return emplace();
    }
 
    template<typename ValueArg>
    iterator emplace(ValueArg&& valueArg)
    {
        return pvEmplace(std::forward_as_tuple(std::get<0>(std::forward<ValueArg>(valueArg))),
            std::forward_as_tuple(std::get<1>(std::forward<ValueArg>(valueArg))));
    }
 
    template<typename ValueArg>
    iterator emplace_hint(const_iterator, ValueArg&& valueArg)
    {
        return emplace(std::forward<ValueArg>(valueArg));
    }
 
    template<typename KeyArg, typename MappedArg>
    iterator emplace(KeyArg&& keyArg, MappedArg&& mappedArg)
    {
        return pvEmplace(std::forward_as_tuple(std::forward<KeyArg>(keyArg)),
            std::forward_as_tuple(std::forward<MappedArg>(mappedArg)));
    }
 
    template<typename KeyArg, typename MappedArg>
    iterator emplace_hint(const_iterator, KeyArg&& keyArg, MappedArg&& mappedArg)
    {
        return emplace(std::forward<KeyArg>(keyArg), std::forward<MappedArg>(mappedArg));
    }
 
    template<typename... KeyArgs, typename... MappedArgs>
    iterator emplace(std::piecewise_construct_t,
        std::tuple<KeyArgs...> keyArgs, std::tuple<MappedArgs...> mappedArgs)
    {
        return pvEmplace(std::move(keyArgs), std::move(mappedArgs));
    }
 
    template<typename... KeyArgs, typename... MappedArgs>
    iterator emplace_hint(const_iterator, std::piecewise_construct_t,
        std::tuple<KeyArgs...> keyArgs, std::tuple<MappedArgs...> mappedArgs)
    {
        return pvEmplace(std::move(keyArgs), std::move(mappedArgs));
    }
 
    iterator erase(const_iterator where)
    {
        typename HashMultiMap::ConstIterator iter = ConstIteratorProxy::GetBaseIterator(where);
        typename HashMultiMap::ConstKeyIterator keyIter = iter.GetKeyIterator();
        return momo::internal::ProxyConstructor<iterator>((keyIter->GetCount() > 1)
            ? mHashMultiMap.Remove(iter)
            : mHashMultiMap.MakeIterator(mHashMultiMap.RemoveKey(keyIter)));
    }
 
    iterator erase(iterator where)
    {
        return erase(static_cast<const_iterator>(where));
    }
 
    iterator erase(const_iterator first, const_iterator last)
    {
        if (first == begin() && last == end())
        {
            clear();
            return end();
        }
        if (first == last)
        {
            return momo::internal::ProxyConstructor<iterator>(mHashMultiMap.MakeMutableIterator(
                ConstIteratorProxy::GetBaseIterator(first)));
        }
        if (first != end())
        {
            if (std::next(first) == last)
                return erase(first);
            typename HashMultiMap::ConstKeyIterator keyIter =
                ConstIteratorProxy::GetBaseIterator(first).GetKeyIterator();
            if (last == momo::internal::ProxyConstructor<const_iterator>(
                mHashMultiMap.MakeIterator(keyIter, keyIter->GetCount())))
            {
                return momo::internal::ProxyConstructor<iterator>(
                    mHashMultiMap.MakeIterator(mHashMultiMap.RemoveKey(keyIter)));
            }
        }
        MOMO_THROW(std::invalid_argument("invalid unordered_multimap erase arguments"));
    }
 
    size_type erase(const key_type& key)
    {
        return mHashMultiMap.RemoveKey(key);
    }
 
    template<typename ValueFilter>
    friend size_type erase_if(unordered_multimap_adaptor& cont, const ValueFilter& valueFilter)
    {
        auto pairFilter = [&valueFilter] (const key_type& key, const mapped_type& mapped)
            { return valueFilter(const_reference(key, mapped)); };
        return cont.mHashMultiMap.Remove(pairFilter);
    }
 
    //iterator insert(node_type&& node)
    //iterator insert(const_iterator, node_type&& node)
    //node_type extract(const_iterator where)
    //node_type extract(const key_type& key)
    //void merge(...)
 
    //size_type max_bucket_count() const noexcept
    //size_type bucket_count() const noexcept
    //size_type bucket_size(size_type bucketIndex) const
    //local_iterator begin(size_type bucketIndex)
    //const_local_iterator begin(size_type bucketIndex) const
    //local_iterator end(size_type bucketIndex)
    //const_local_iterator end(size_type bucketIndex) const
    //const_local_iterator cbegin(size_type bucketIndex) const
    //const_local_iterator cend(size_type bucketIndex) const
    //size_type bucket(const key_type& key) const
    //float load_factor() const noexcept
 
    friend bool operator==(const unordered_multimap_adaptor& left,
        const unordered_multimap_adaptor& right)
    {
        if (left.mHashMultiMap.GetKeyCount() != right.mHashMultiMap.GetKeyCount())
            return false;
        if (left.mHashMultiMap.GetCount() != right.mHashMultiMap.GetCount())
            return false;
        typedef typename HashMultiMap::ConstKeyIterator ConstKeyIterator;
        for (typename ConstKeyIterator::Reference ref : left.mHashMultiMap.GetKeyBounds())
        {
            if (ref.GetCount() == 0)
                continue;
            ConstKeyIterator rightKeyIter = right.mHashMultiMap.Find(ref.key);
            if (!rightKeyIter)
                return false;
            if (ref.GetCount() != rightKeyIter->GetCount())
                return false;
            if (!std::is_permutation(ref.GetBegin(), ref.GetEnd(), rightKeyIter->GetBegin()))
                return false;
        }
        return true;
    }
 
    friend bool operator!=(const unordered_multimap_adaptor& left,
        const unordered_multimap_adaptor& right)
    {
        return !(left == right);
    }
 
private:
    template<typename Iterator, typename HashMultiMap, typename KeyIterator>
    static std::pair<Iterator, Iterator> pvEqualRange(HashMultiMap& hashMultiMap,
        KeyIterator keyIter)
    {
        Iterator end = momo::internal::ProxyConstructor<Iterator>(hashMultiMap.GetEnd());
        if (!keyIter)
            return { end, end };
        size_t count = keyIter->GetCount();
        if (count == 0)
            return { end, end };
        Iterator first = momo::internal::ProxyConstructor<Iterator>(
            hashMultiMap.MakeIterator(keyIter, 0));
        Iterator last = momo::internal::ProxyConstructor<Iterator>(
            hashMultiMap.MakeIterator(keyIter, count));
        return { first, last };
    }
 
    template<typename... KeyArgs, typename... MappedArgs>
    iterator pvEmplace(std::tuple<KeyArgs...>&& keyArgs, std::tuple<MappedArgs...>&& mappedArgs)
    {
        typedef typename HashMultiMap::KeyValueTraits
            ::template ValueCreator<MappedArgs...> MappedCreator;
        return pvInsert(std::move(keyArgs),
            MappedCreator(mHashMultiMap.GetMemManager(), std::move(mappedArgs)));
    }
 
    template<typename... KeyArgs, typename MappedCreator>
    iterator pvInsert(std::tuple<KeyArgs...>&& keyArgs, MappedCreator&& mappedCreator)
    {
        MemManager& memManager = mHashMultiMap.GetMemManager();
        typedef momo::internal::ObjectBuffer<key_type, HashMultiMap::KeyValueTraits::keyAlignment> KeyBuffer;
        typedef momo::internal::ObjectManager<key_type, MemManager> KeyManager;
        typedef typename KeyManager::template Creator<KeyArgs...> KeyCreator;
        KeyBuffer keyBuffer;
        KeyCreator(memManager, std::move(keyArgs))(keyBuffer.GetPtr());
        typename KeyManager::DestroyFinalizer keyFin(&memManager, keyBuffer.Get());
        return pvInsert(std::forward_as_tuple(std::move(keyBuffer.Get())),
            std::forward<MappedCreator>(mappedCreator));
    }
 
    template<typename RKey, typename MappedCreator,
        typename Key = typename std::decay<RKey>::type>
    momo::internal::EnableIf<std::is_same<key_type, Key>::value,
    iterator> pvInsert(std::tuple<RKey>&& key, MappedCreator&& mappedCreator)
    {
        return momo::internal::ProxyConstructor<iterator>(mHashMultiMap.AddCrt(
            std::forward<RKey>(std::get<0>(key)), std::forward<MappedCreator>(mappedCreator)));
    }
 
    template<typename Iterator, typename Sentinel>
    momo::internal::EnableIf<momo::internal::IsMapArgIteratorStd<Iterator, key_type>::value,
    void> pvInsertRange(Iterator begin, Sentinel end)
    {
        mHashMultiMap.Add(std::move(begin), std::move(end));
    }
 
    template<typename Iterator, typename Sentinel>
    momo::internal::EnableIf<!momo::internal::IsMapArgIteratorStd<Iterator, key_type>::value,
    void> pvInsertRange(Iterator begin, Sentinel end)
    {
        for (Iterator iter = std::move(begin); iter != end; ++iter)
            insert(*iter);
    }
 
private:
    HashMultiMap mHashMultiMap;
};
 
template<typename TKey, typename TMapped,
    typename THasher = HashCoder<TKey>,
    typename TEqualComparer = std::equal_to<TKey>,
    typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>>
class unordered_multimap : public unordered_multimap_adaptor<HashMultiMap<TKey, TMapped,
    HashTraitsStd<TKey, THasher, TEqualComparer, HashBucketDefault>, MemManagerStd<TAllocator>>>
{
private:
    typedef unordered_multimap_adaptor<momo::HashMultiMap<TKey, TMapped,
        HashTraitsStd<TKey, THasher, TEqualComparer, HashBucketDefault>,
            MemManagerStd<TAllocator>>> UnorderedMultiMapAdaptor;
 
public:
    using UnorderedMultiMapAdaptor::UnorderedMultiMapAdaptor;
 
    unordered_multimap& operator=(
        std::initializer_list<typename UnorderedMultiMapAdaptor::value_type> values)
    {
        UnorderedMultiMapAdaptor::operator=(values);
        return *this;
    }
 
    friend void swap(unordered_multimap& left, unordered_multimap& right) noexcept
    {
        left.swap(right);
    }
};
 
template<typename TKey, typename TMapped,
    typename THasher = HashCoder<TKey>,
    typename TEqualComparer = std::equal_to<TKey>,
    typename TAllocator = std::allocator<std::pair<const TKey, TMapped>>>
class unordered_multimap_open : public unordered_multimap_adaptor<HashMultiMap<TKey, TMapped,
    HashTraitsStd<TKey, THasher, TEqualComparer, HashBucketOpenDefault>, MemManagerStd<TAllocator>>>
{
private:
    typedef unordered_multimap_adaptor<momo::HashMultiMap<TKey, TMapped,
        HashTraitsStd<TKey, THasher, TEqualComparer, HashBucketOpenDefault>,
            MemManagerStd<TAllocator>>> UnorderedMultiMapAdaptor;
 
public:
    using UnorderedMultiMapAdaptor::UnorderedMultiMapAdaptor;
 
    unordered_multimap_open& operator=(
        std::initializer_list<typename UnorderedMultiMapAdaptor::value_type> values)
    {
        UnorderedMultiMapAdaptor::operator=(values);
        return *this;
    }
 
    friend void swap(unordered_multimap_open& left, unordered_multimap_open& right) noexcept
    {
        left.swap(right);
    }
};
 
#ifdef MOMO_HAS_DEDUCTION_GUIDES
 
#define MOMO_DECLARE_DEDUCTION_GUIDES(unordered_multimap) \
template<typename Iterator, \
    typename Value = typename std::iterator_traits<Iterator>::value_type, \
    typename Key = std::decay_t<typename Value::first_type>, \
    typename Mapped = std::decay_t<typename Value::second_type>> \
unordered_multimap(Iterator, Iterator) \
    -> unordered_multimap<Key, Mapped>; \
template<typename Iterator, \
    typename Value = typename std::iterator_traits<Iterator>::value_type, \
    typename Key = std::decay_t<typename Value::first_type>, \
    typename Mapped = std::decay_t<typename Value::second_type>, \
    typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
    typename = internal::hash_checker<Key, Allocator, HashCoder<Key>>> \
unordered_multimap(Iterator, Iterator, size_t, Allocator = Allocator()) \
    -> unordered_multimap<Key, Mapped, HashCoder<Key>, std::equal_to<Key>, Allocator>; \
template<typename Iterator, typename Hasher, \
    typename Value = typename std::iterator_traits<Iterator>::value_type, \
    typename Key = std::decay_t<typename Value::first_type>, \
    typename Mapped = std::decay_t<typename Value::second_type>, \
    typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
    typename = internal::hash_checker<Key, Allocator, Hasher>> \
unordered_multimap(Iterator, Iterator, size_t, Hasher, Allocator = Allocator()) \
    -> unordered_multimap<Key, Mapped, Hasher, std::equal_to<Key>, Allocator>; \
template<typename Iterator, typename Hasher, typename EqualComparer, \
    typename Value = typename std::iterator_traits<Iterator>::value_type, \
    typename Key = std::decay_t<typename Value::first_type>, \
    typename Mapped = std::decay_t<typename Value::second_type>, \
    typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
    typename = internal::hash_checker<Key, Allocator, Hasher, EqualComparer>> \
unordered_multimap(Iterator, Iterator, size_t, Hasher, EqualComparer, Allocator = Allocator()) \
    -> unordered_multimap<Key, Mapped, Hasher, EqualComparer, Allocator>; \
template<typename QKey, typename Mapped, \
    typename Key = std::remove_const_t<QKey>> \
unordered_multimap(std::initializer_list<std::pair<QKey, Mapped>>) \
    -> unordered_multimap<Key, Mapped>; \
template<typename QKey, typename Mapped, \
    typename Key = std::remove_const_t<QKey>, \
    typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
    typename = internal::hash_checker<Key, Allocator, HashCoder<Key>>> \
unordered_multimap(std::initializer_list<std::pair<QKey, Mapped>>, size_t, Allocator = Allocator()) \
    -> unordered_multimap<Key, Mapped, HashCoder<Key>, std::equal_to<Key>, Allocator>; \
template<typename QKey, typename Mapped, typename Hasher, \
    typename Key = std::remove_const_t<QKey>, \
    typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
    typename = internal::hash_checker<Key, Allocator, Hasher>> \
unordered_multimap(std::initializer_list<std::pair<QKey, Mapped>>, size_t, Hasher, Allocator = Allocator()) \
    -> unordered_multimap<Key, Mapped, Hasher, std::equal_to<Key>, Allocator>; \
template<typename QKey, typename Mapped, typename Hasher, typename EqualComparer, \
    typename Key = std::remove_const_t<QKey>, \
    typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
    typename = internal::hash_checker<Key, Allocator, Hasher, EqualComparer>> \
unordered_multimap(std::initializer_list<std::pair<QKey, Mapped>>, size_t, \
    Hasher, EqualComparer, Allocator = Allocator()) \
    -> unordered_multimap<Key, Mapped, Hasher, EqualComparer, Allocator>; \
template<typename Key, typename Mapped, typename Hasher, typename EqualComparer, typename Allocator> \
unordered_multimap(unordered_multimap<Key, Mapped, Hasher, EqualComparer, Allocator>, \
    momo::internal::Identity<Allocator>) \
    -> unordered_multimap<Key, Mapped, Hasher, EqualComparer, Allocator>;
 
MOMO_DECLARE_DEDUCTION_GUIDES(unordered_multimap)
MOMO_DECLARE_DEDUCTION_GUIDES(unordered_multimap_open)
 
#undef MOMO_DECLARE_DEDUCTION_GUIDES
 
#ifdef MOMO_HAS_CONTAINERS_RANGES
 
#define MOMO_DECLARE_DEDUCTION_GUIDES_RANGES(unordered_multimap) \
template<std::ranges::input_range Range, \
    typename Value = std::ranges::range_value_t<Range>, \
    typename Key = std::decay_t<typename Value::first_type>, \
    typename Mapped = std::decay_t<typename Value::second_type>> \
unordered_multimap(std::from_range_t, Range&&) \
    -> unordered_multimap<Key, Mapped>; \
template<std::ranges::input_range Range, \
    typename Value = std::ranges::range_value_t<Range>, \
    typename Key = std::decay_t<typename Value::first_type>, \
    typename Mapped = std::decay_t<typename Value::second_type>, \
    typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
    typename = internal::hash_checker<Key, Allocator, HashCoder<Key>>> \
unordered_multimap(std::from_range_t, Range&&, size_t, Allocator = Allocator()) \
    -> unordered_multimap<Key, Mapped, HashCoder<Key>, std::equal_to<Key>, Allocator>; \
template<std::ranges::input_range Range, typename Hasher, \
    typename Value = std::ranges::range_value_t<Range>, \
    typename Key = std::decay_t<typename Value::first_type>, \
    typename Mapped = std::decay_t<typename Value::second_type>, \
    typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
    typename = internal::hash_checker<Key, Allocator, Hasher>> \
unordered_multimap(std::from_range_t, Range&&, size_t, Hasher, Allocator = Allocator()) \
    -> unordered_multimap<Key, Mapped, Hasher, std::equal_to<Key>, Allocator>; \
template<std::ranges::input_range Range, typename Hasher, typename EqualComparer, \
    typename Value = std::ranges::range_value_t<Range>, \
    typename Key = std::decay_t<typename Value::first_type>, \
    typename Mapped = std::decay_t<typename Value::second_type>, \
    typename Allocator = std::allocator<std::pair<const Key, Mapped>>, \
    typename = internal::hash_checker<Key, Allocator, Hasher, EqualComparer>> \
unordered_multimap(std::from_range_t, Range&&, size_t, Hasher, EqualComparer, Allocator = Allocator()) \
    -> unordered_multimap<Key, Mapped, Hasher, EqualComparer, Allocator>;
 
MOMO_DECLARE_DEDUCTION_GUIDES_RANGES(unordered_multimap)
MOMO_DECLARE_DEDUCTION_GUIDES_RANGES(unordered_multimap_open)
 
#undef MOMO_DECLARE_DEDUCTION_GUIDES_RANGES
 
#endif // MOMO_HAS_CONTAINERS_RANGES
 
#endif // MOMO_HAS_DEDUCTION_GUIDES
 
} // namespace stdish
 
} // namespace momo
 
#endif // MOMO_INCLUDE_GUARD_STDISH_UNORDERED_MULTIMAP