クラス・テンプレートの概要

// <oneapi/tbb/concurrent_hash_map.h> ヘッダーで定義 
    namespace oneapi { 
        namespace tbb { 
            template <typename Key, typename T, 
                typename HashCompare = tbb_hash_compare<Key>, 
                typename Allocator = tbb_allocator<std::pair<const Key, T>>> 
    class concurrent_hash_map { 
        public: 
        using key_type = Key; 
        using mapped_type = T; 
        using value_type = std::pair<const Key, T

        >; using reference = value_type&; 
        using const_reference = const value_type&; 
        using pointer = typename std::allocator_traits<Allocator>::pointer; 
        using const_pointer = typename std::allocator_traits<Allocator>::const_pointer; 

        using hash_compare_type = HashCompare; 
        using allocator_type = Allocator; 
    
        using size_type = <implementation-defined unsigned integer type>; 
        using difference_type = <implementation-defined signed integer type>; 

        using iterator = <implementation-defined ForwardIterator>; 
        using const_iterator = <implementation-defined constant ForwardIterator>; 

        using range_type = <implementation-defined ContainerRange>; 
        using const_range_type = <implementation-defined constant ContainerRange>; 

        class accessor; 
        class const_accessor; 

        // Construction, destruction, copying 
        concurrent_hash_map(); 

        explicit concurrent_hash_map( const hash_compare_type& compare, 
                               const allocator_type& alloc = allocator_type() ); 

        explicit concurrent_hash_map( const allocator_type& alloc ); 

        concurrent_hash_map( size_type n, const hash_compare_type& compare, 
                               const allocator_type& alloc = allocator_type() ); 

        concurrent_hash_map( size_type n, const allocator_type& alloc = allocator_type() ); 

        template <typename InputIterator> 
        concurrent_hash_map( InputIterator first, InputIterator last, 
                               const hash_compare_type& compare, 
                               const allocator_type& alloc = allocator_type() ); 

        template <typename InputIterator> 
        concurrent_hash_map( InputIterator first, InputIterator last, 
                               const allocator_type& alloc = allocator_type() ); 

        concurrent_hash_map( std::initializer_list<value_type> init, 
                               const hash_compare_type& compare = hash_compare_type(), 
                               const allocator_type& alloc = allocator_type() ); 

        concurrent_hash_map( std::initializer_list<value_type> init, 
                               const allocator_type& alloc ); 

        concurrent_hash_map( const concurrent_hash_map& other ); 
        concurrent_hash_map( const concurrent_hash_map& other, 
                               const allocator_type& alloc ); 

        concurrent_hash_map( concurrent_hash_map&& other ); 
        concurrent_hash_map( concurrent_hash_map&& other, 
                               const allocator_type& alloc ); 

        ~concurrent_hash_map(); 

        concurrent_hash_map& operator=( const concurrent_hash_map& other ); 
        concurrent_hash_map& operator=( concurrent_hash_map&& other ); 
        concurrent_hash_map& operator=( std::initializer_list<value_type> init ); 

        allocator_type get_allocator() const; 

        // Concurrently unsafe modifiers 
        void clear(); 

        void swap( concurrent_hash_map& other ); 
    
        // Hash policy 
        void rehash( size_type sz = 0 ); 
        size_type bucket_count() const; 

        // Size and capacity 
        size_type size() const; 
        bool empty() const; 
        size_type max_size() const; 

        // Lookup 
        bool find( const_accessor& result, const key_type& key ) const; 
        bool find( accessor& result, const key_type& key ); 

        template <typename K> 
        bool find( const_accessor& result, const K& key ) const; 
    
        template <typename K> 
        bool find( accessor& result, const K& key ); 

        size_type count( const key_type& key ) const; 

        template <typename K> 
        size_type count( const K& key ) const; 

        // Modifiers 
        bool insert( const_accessor& result, const key_type& key ); 
        bool insert( accessor& result, const key_type& key ); 
    
        template <typename K> 
        bool insert( const_accessor& result, const K& key ); 

        template <typename K> 
        bool insert( accessor& result, const K& key ); 

        bool insert( const_accessor& result, const value_type& value ); 
        bool insert( accessor& result, const value_type& value ); 
        bool insert( const_accessor& result, value_type&& value ); 
        bool insert( accessor& result, value_type&& value );
 
        bool insert( const value_type& value ); 
        bool insert( value_type&& value ); 

        template <typename InputIterator> 
        void insert( InputIterator first, InputIterator last ); 

        void insert( std::initializer_list<value_type> init ); 

        template <typename...Args> 
        bool emplace( const_accessor& result, Args&&... args ); 

        template <typename... Args> 
        bool emplace( accessor& result, Args&&... args ); 
    
        template <typename... Args> 
        bool emplace( Args&&... args ); 

        bool erase( const key_type& key ); 

        template <typename K> 
        bool erase( const K& key ); 

        bool erase( const_accessor& item_accessor ); 
        bool erase( accessor& item_accessor ); 

        // Iterators 
        iterator begin(); 
        const_iterator begin() const; 
        const_iterator cbegin() const; 

        iterator end(); 
        const_iterator end() const; 
        const_iterator cend() const; 

        std::pair<iterator, iterator> equal_range( const key_type& key ); 
        std::pair<const_iterator, const_iterator> equal_range( const key_type& key ) const; 

        template <typename K
        > std::pair<iterator, iterator> equal_range( const K& key ); 

        template <typename K
        > std::pair<const_iterator, const_iterator> equal_range( const K& key ) const; 

        // Parallel iteration 
        range_type range( std::size_t grainsize = 1 ); 
        const_range_type range( std::size_t grainsize = 1 ) const; 
    }; // class concurrent_hash_map 
} // namespace tbb 
} // namespace oneapi

要件:

• 式 std::allocator_type<Allocator>::destroy(m, val) (m は Allocator タイプのオブジェクト、val は value_type タイプのオブジェクト) は、整数式でなければなりません。メンバー関数は、操作タイプに応じてより厳密な要件を課す場合があります。

• HashCompare タイプは、HashCompare 要件を満たしている必要があります。

• Allocator タイプは、[allocator.requirements] ISO C++ 標準の Allocator 要件を満たしている必要があります。

メンバークラス

メンバー関数

非メンバー関数

これらの関数は、oneapi::tbb::concurrent_hash_map オブジェクトに対するバイナリー比較およびスワップ操作を提供します。

これらの関数が定義される名前空間は、それぞれの比較操作で使用できるかぎり未指定です。例えば、実装では、同じ内部名前空間でクラスと関数を定義し oneapi::tbb::concurrent_hash_map をタイプエイリアスとして定義できます。この場合、非メンバー関数には引数依存のルックアップによってのみ到達できます。

template <typename Key, typename T, typename HashCompare, typename Allocator> 
bool operator==( const concurrent_hash_map<Key, T, HashCompare, Allocator>& lhs, 
                          const concurrent_hash_map<Key, T, HashCompare, Allocator>& rhs ); 

template <typename Key, typename T, typename HashCompare, typename Allocator> 
bool operator!=( const concurrent_hash_map<Key, T, HashCompare, Allocator>& lhs, 
                          const concurrent_hash_map<Key, T, HashCompare, Allocator>& rhs ); 

template <typename Key, typename T, typename HashCompare, typename Allocator> 
void swap( concurrent_hash_map<Key, T, HashCompare, Allocator>& lhs, 
                          concurrent_hash_map<Key, T, HashCompare, Allocator>& rhs );

その他