concurrent_unordered_map.h

Go to the documentation of this file.

/***
* ==++==
*
* Copyright (c) Microsoft Corporation.  All rights reserved.
*
* ==--==
* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
*
* concurrent_unordered_map.h
*
* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
****/
#pragma once

#include <utility>
#include "internal_concurrent_hash.h"

#define _PPL_CONTAINER

#if !(defined (_M_X64) || defined (_M_IX86) || defined (_M_ARM) || defined (_M_ARM64))
    #error ERROR: Concurrency Runtime is supported only on X64, X86, ARM, and ARM64 architectures.
#endif  /* !(defined (_M_X64) || defined (_M_IX86) || defined (_M_ARM) || defined (_M_ARM64)) */

#if defined (_M_CEE)
    #error ERROR: Concurrency Runtime is not supported when compiling /clr.
#endif  /* defined (_M_CEE) */

#pragma pack(push,_CRT_PACKING)
#pragma warning(push)
#pragma warning(disable: 4100) // Unreferenced formal parameter - needed for document generation

namespace Concurrency
{
namespace details
{
// Template class for hash map traits
template<typename _Key_type, typename _Element_type, typename _Key_comparator, typename _Allocator_type, bool _Allow_multimapping>
class _Concurrent_unordered_map_traits : public std::_Container_base
{
public:
    typedef std::pair<const _Key_type, _Element_type> value_type;
    typedef _Key_type key_type;
    typedef _Key_comparator _Key_compare;

    typedef typename _Allocator_type::template rebind<value_type>::other allocator_type;

    enum
    {
        _M_allow_multimapping = _Allow_multimapping
    };

    _Concurrent_unordered_map_traits() : _M_comparator()
    {
    }

    _Concurrent_unordered_map_traits(const _Key_compare& _Traits) : _M_comparator(_Traits)
    {
    }

    class _Value_compare
    {
        friend class _Concurrent_unordered_map_traits<_Key_type, _Element_type, _Key_comparator, _Allocator_type, _Allow_multimapping>;

    public:
        typedef value_type first_argument_type;
        typedef value_type second_argument_type;
        typedef bool result_type;

        bool operator()(const value_type& _Left, const value_type& _Right) const
        {
            return (_M_comparator(_Left.first, _Right.first));
        }

        _Value_compare(const _Key_compare& _Traits) : _M_comparator(_Traits)
        {
        }

    protected:
        _Key_compare _M_comparator;    // the comparator predicate for keys
    };

    template<class _Type1, class _Type2>
    static const _Type1& _Key_function(const std::pair<_Type1, _Type2>& _Value)
    {
        return (_Value.first);
    }
    _Key_compare _M_comparator; // the comparator predicate for keys
};
} // namespace details;


template <typename _Key_type, typename _Element_type, typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> > >
class concurrent_unordered_map : public details::_Concurrent_hash< details::_Concurrent_unordered_map_traits<_Key_type, _Element_type, details::_Hash_compare<_Key_type, _Hasher, _Key_equality>, _Allocator_type, false> >
{
public:
    // Base type definitions
    typedef concurrent_unordered_map<_Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type> _Mytype;
    typedef details::_Hash_compare<_Key_type, _Hasher, _Key_equality> _Key_compare;
    typedef details::_Concurrent_hash< details::_Concurrent_unordered_map_traits<_Key_type, _Element_type, _Key_compare, _Allocator_type, false> > _Mybase;

    
    typedef _Key_type key_type;

    
    typedef typename _Mybase::value_type value_type;

    
    typedef _Element_type mapped_type;

    
    typedef _Hasher hasher;

    
    typedef _Key_equality key_equal;

    
    typedef typename _Mybase::allocator_type allocator_type;

    
    typedef typename _Mybase::pointer pointer;

    
    typedef typename _Mybase::const_pointer const_pointer;

    
    typedef typename _Mybase::reference reference;

    
    typedef typename _Mybase::const_reference const_reference;

    
    typedef typename _Mybase::size_type size_type;

    
    typedef typename _Mybase::difference_type difference_type;

    
    typedef typename _Mybase::iterator iterator;

    
    typedef typename _Mybase::const_iterator const_iterator;

    
    typedef typename _Mybase::iterator local_iterator;

    
    typedef typename _Mybase::const_iterator const_local_iterator;

    
    explicit concurrent_unordered_map(size_type _Number_of_buckets = 8, const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
        const allocator_type& _Allocator = allocator_type())
        : _Mybase(_Number_of_buckets, _Key_compare(_Hasher, _Key_equality), _Allocator)
    {
        this->rehash(_Number_of_buckets);
    }

    
    concurrent_unordered_map(const allocator_type& _Allocator) : _Mybase(8, _Key_compare(), _Allocator)
    {
    }

    
    template <typename _Iterator>
    concurrent_unordered_map(_Iterator _Begin, _Iterator _End, size_type _Number_of_buckets = 8, const hasher& _Hasher = hasher(),
        const key_equal& _Key_equality = key_equal(), const allocator_type& _Allocator = allocator_type())
        : _Mybase(_Number_of_buckets, _Key_compare(), allocator_type())
    {
        this->rehash(_Number_of_buckets);
        for (; _Begin != _End; ++_Begin)
        {
            this->_Insert(*_Begin);
        }
    }

    
    concurrent_unordered_map(const concurrent_unordered_map& _Umap) : _Mybase(_Umap)
    {
    }

    
    concurrent_unordered_map(const concurrent_unordered_map& _Umap, const allocator_type& _Allocator) : _Mybase(_Umap, _Allocator)
    {
    }

    
    concurrent_unordered_map(concurrent_unordered_map&& _Umap) : _Mybase(std::move(_Umap))
    {
    }

    
    concurrent_unordered_map& operator=(const concurrent_unordered_map& _Umap)
    {
        _Mybase::operator=(_Umap);
        return (*this);
    }

    
    concurrent_unordered_map& operator=(concurrent_unordered_map&& _Umap)
    {
        _Mybase::operator=(std::move(_Umap));
        return (*this);
    }

    
    std::pair<iterator, bool> insert(const value_type& _Value)
    {
        return this->_Insert(_Value);
    }

    
    iterator insert(const_iterator _Where, const value_type& _Value)
    {
        // Current implementation ignores the hint. The method is provided for compatibility with unordered_map.
        return this->_Insert(_Value).first;
    }

    
    template<class _Iterator>
    void insert(_Iterator _First, _Iterator _Last)
    {
        this->_Insert(_First, _Last);
    }

    
    template<class _Valty>
    std::pair<iterator, bool> insert(_Valty&& _Value)
    {
        return this->_Insert(std::forward<_Valty>(_Value));
    }

    
    template<class _Valty>
        typename std::enable_if<!std::is_same<const_iterator,
            typename std::remove_reference<_Valty>::type>::value, iterator>::type
    insert(const_iterator _Where, _Valty&& _Value)
    {
        // Current implementation ignores the hint. The method is provided for compatibility with unordered_map.
        return this->_Insert(std::forward<_Valty>(_Value)).first;
    }

    
    iterator unsafe_erase(const_iterator _Where)
    {
        return _Mybase::unsafe_erase(_Where);
    }

    
    iterator unsafe_erase(const_iterator _Begin, const_iterator _End)
    {
        return _Mybase::unsafe_erase(_Begin, _End);
    }

    
    size_type unsafe_erase(const key_type& _Keyval)
    {
        return _Mybase::unsafe_erase(_Keyval);
    }

    
    void swap(concurrent_unordered_map& _Umap)
    {
        _Mybase::swap(_Umap);
    }

    
    hasher hash_function() const
    {
        return this->_M_comparator._M_hash_object;
    }

    
    key_equal key_eq() const
    {
        return this->_M_comparator._M_key_compare_object;
    }

    
    mapped_type& operator[](const key_type& _Keyval)
    {
        iterator _Where = this->find(_Keyval);

        if (_Where == this->end())
        {
            _Where = this->_Insert(std::make_pair(_Keyval, mapped_type())).first;
        }

        return ((*_Where).second);
    }

    
    mapped_type& operator[](key_type && _Keyval)
    {
        iterator _Where = this->find(_Keyval);

        if (_Where == this->end())
        {
            _Where = this->_Insert(std::make_pair(std::forward<key_type>(_Keyval), mapped_type())).first;
        }

        return ((*_Where).second);
    }

    
    mapped_type& at(const key_type& _Keyval)
    {
        iterator _Where = this->find(_Keyval);

        if (_Where == this->end())
        {
            throw std::out_of_range("invalid concurrent_unordered_map<K, T> key");
        }

        return ((*_Where).second);
    }

    
    const mapped_type& at(const key_type& _Keyval) const
    {
        const_iterator _Where = this->find(_Keyval);

        if (_Where == this->end())
        {
            throw std::out_of_range("invalid concurrent_unordered_map<K, T> key");
        }

        return ((*_Where).second);
    }
};


template <typename _Key_type, typename _Element_type, typename _Hasher = std::hash<_Key_type>, typename _Key_equality = std::equal_to<_Key_type>, typename _Allocator_type = std::allocator<std::pair<const _Key_type, _Element_type> > >
class concurrent_unordered_multimap : public details::_Concurrent_hash< details::_Concurrent_unordered_map_traits<_Key_type, _Element_type, details::_Hash_compare<_Key_type, _Hasher, _Key_equality>, _Allocator_type, true> >
{
public:
    // Base type definitions
    typedef concurrent_unordered_multimap<_Key_type, _Element_type, _Hasher, _Key_equality, _Allocator_type> _Mytype;
    typedef details::_Hash_compare<_Key_type, _Hasher, _Key_equality> _Key_compare;
    typedef details::_Concurrent_hash< details::_Concurrent_unordered_map_traits<_Key_type, _Element_type, _Key_compare, _Allocator_type, true> > _Mybase;

    
    typedef _Key_type key_type;

    
    typedef typename _Mybase::value_type value_type;

    
    typedef _Element_type mapped_type;

    
    typedef _Hasher hasher;

    
    typedef _Key_equality key_equal;

    
    typedef typename _Mybase::allocator_type allocator_type;

    
    typedef typename _Mybase::pointer pointer;

    
    typedef typename _Mybase::const_pointer const_pointer;

    
    typedef typename _Mybase::reference reference;

    
    typedef typename _Mybase::const_reference const_reference;

    
    typedef typename _Mybase::size_type size_type;

    
    typedef typename _Mybase::difference_type difference_type;

    
    typedef typename _Mybase::iterator iterator;

    
    typedef typename _Mybase::const_iterator const_iterator;

    
    typedef typename _Mybase::iterator local_iterator;

    
    typedef typename _Mybase::const_iterator const_local_iterator;

    
    explicit concurrent_unordered_multimap(size_type _Number_of_buckets = 8, const hasher& _Hasher = hasher(), const key_equal& _Key_equality = key_equal(),
        const allocator_type& _Allocator = allocator_type())
        : _Mybase(_Number_of_buckets, _Key_compare(_Hasher, _Key_equality), _Allocator)
    {
        this->rehash(_Number_of_buckets);
    }

    
    concurrent_unordered_multimap(const allocator_type& _Allocator) : _Mybase(8, _Key_compare(), _Allocator)
    {
    }

    
    template <typename _Iterator>
    concurrent_unordered_multimap(_Iterator _Begin, _Iterator _End, size_type _Number_of_buckets = 8, const hasher& _Hasher = hasher(),
        const key_equal& _Key_equality = key_equal(), const allocator_type& _Allocator = allocator_type())
        : _Mybase(_Number_of_buckets, _Key_compare(), allocator_type())
    {
        this->rehash(_Number_of_buckets);
        for (; _Begin != _End; ++_Begin)
        {
            this->_Insert(*_Begin);
        }
    }

    
    concurrent_unordered_multimap(const concurrent_unordered_multimap& _Umap) : _Mybase(_Umap)
    {
    }

    
    concurrent_unordered_multimap(const concurrent_unordered_multimap& _Umap, const allocator_type& _Allocator) : _Mybase(_Umap, _Allocator)
    {
    }

    
    concurrent_unordered_multimap(concurrent_unordered_multimap&& _Umap) : _Mybase(std::move(_Umap))
    {
    }

    
    concurrent_unordered_multimap& operator=(const concurrent_unordered_multimap& _Umap)
    {
        _Mybase::operator=(_Umap);
        return (*this);
    }

    
    concurrent_unordered_multimap& operator=(concurrent_unordered_multimap&& _Umap)
    {
        _Mybase::operator=(std::move(_Umap));
        return (*this);
    }

    
    iterator insert(const value_type& _Value)
    {
        return this->_Insert(_Value).first;
    }

    
    iterator insert(const_iterator _Where, const value_type& _Value)
    {
        // Current implementation ignores the hint. The method is provided for compatibility with unordered_multimap.
        return this->_Insert(_Value).first;
    }

    
    template<class _Iterator>
    void insert(_Iterator _First, _Iterator _Last)
    {
        this->_Insert(_First, _Last);
    }

    
    template<class _Valty>
    iterator insert(_Valty&& _Value)
    {
        return this->_Insert(std::forward<_Valty>(_Value)).first;
    }

    
    template<class _Valty>
        typename std::enable_if<!std::is_same<const_iterator, typename std::remove_reference<_Valty>::type>::value, iterator>::type
    insert(const_iterator _Where, _Valty&& _Value)
    {
        // Current implementation ignores the hint. The method is provided for compatibility with unordered_multimap.
        return this->_Insert(std::forward<_Valty>(_Value)).first;
    }

    
    iterator unsafe_erase(const_iterator _Where)
    {
        return _Mybase::unsafe_erase(_Where);
    }

    
    size_type unsafe_erase(const key_type& _Keyval)
    {
        return _Mybase::unsafe_erase(_Keyval);
    }

    
    iterator unsafe_erase(const_iterator _First, const_iterator _Last)
    {
        return _Mybase::unsafe_erase(_First, _Last);
    }

    
    void swap(concurrent_unordered_multimap& _Umap)
    {
        _Mybase::swap(_Umap);
    }

    
    hasher hash_function() const
    {
        return this->_M_comparator._M_hash_object;
    }

    
    key_equal key_eq() const
    {
        return this->_M_comparator._M_key_compare_object;
    }
};
} // namespace Concurrency

namespace concurrency = ::Concurrency;

#pragma warning(pop)
#pragma pack(pop)