concurrent_unordered_set

[containers.concurrent_unordered_set]

oneapi::tbb::concurrent_unordered_set は、一意の要素の順序付けされていないシーケンスを表わすクラス・テンプレートです。同時挿入、ルックアップ、おとび走査をサポートしますが、同時消去はサポートされません。

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

// <oneapi/tbb/concurrent_unordered_set.h> ヘッダーで定義 

namespace oneapi { 
    namespace tbb { 
        template <typename T, 
                  typename Hash = std::hash<Key>, 
                  typename KeyEqual = std::equal_to<Key>, 
                  typename Allocator = tbb_allocator<std::pair<const Key, T>>> 
        class concurrent_unordered_set { 
        public: 
            using key_type = Key; 
            using value_type = Key; 

            using size_type = <implementation-defined unsigned integer type>; 
            using difference_type = <implementation-defined signed integer type>; 

            using hasher = Hash; 
            using key_equal = /*See below*/; 

            using allocator_type = Allocator; 

            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 iterator = <implementation-defined ForwardIterator>; 
            using const_iterator = <implementation-defined constant ForwardIterator>; 

            using local_iterator = <implementation-defined ForwardIterator>; 
            using const_local_iterator = <implementation-defined constant ForwardIterator>; 

            using node_type = <implementation-defined node handle>; 

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

            // Construction, destruction, copying 
            concurrent_unordered_set(); 

            explicit concurrent_unordered_set( size_type bucket_count, const hasher& hash = hasher(), 
                                               const key_equal& equal = key_equal(), 
                                               const allocator_type& alloc = allocator_type() ); 

            concurrent_unordered_set( size_type bucket_count, const allocator_type& alloc ); 

            concurrent_unordered_set( size_type bucket_count, const hasher& hash, 
                                      const allocator_type& alloc ); 

            explicit concurrent_unordered_set( const allocator_type& alloc ); 

            template <typename InputIterator> 
            concurrent_unordered_set( InputIterator first, InputIterator last, 
                                      size_type bucket_count = /*implementation-defined*/, 
                                      const hasher& hash = hasher(), 
                                      const key_equal& equal = key_equal(), 
                                      const allocator_type& alloc = allocator_type() ); 

            template <typename Inputiterator> 
            concurrent_unordered_set( InputIterator first, InputIterator last, 
                                      size_type bucket_count, const allocator_type& alloc ); 

            template <typename InputIterator> 
            concurrent_unordered_set( InputIterator first, InputIterator last, 
                                      size_type bucket_count, const hasher& hash, 
                                      const allocator_type& alloc ); 

            concurrent_unordered_set( std::initializer_list<value_type> init, 
                                      size_type bucket_count = /*implementation-defined*/, 
                                      const hasher& hash = hasher(), 
                                      const key_equal& equal = key_equal(), 
                                      const allocator_type& alloc = allocator_type() ); 

            concurrent_unordered_set( std::initializer_list<value_type> init, 
                                      size_type bucket_count, const allocator_type& alloc ); 

            concurrent_unordered_set( std::initializer_list<value_type> init, 
                                      size_type bucket_count, const hasher& hash, 
                                      const allocator_type& alloc ); 

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

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

            ~concurrent_unordered_set(); 

            concurrent_unordered_set& operator=( const concurrent_unordered_set& other ); 
            concurrent_unordered_set& operator=( concurrent_unordered_set&& other ) noexcept(/*See details*/); 

            concurrent_unordered_set& operator=( std::initializer_list<value_type> init ); 

           allocator_type get_allocator() const; 

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

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

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

            // Concurrently safe modifiers 
            std::pair<iterator, bool> insert( const value_type& value ); 
            iterator insert( const_iterator hint, const value_type& value ); 

            std::pair<iterator, bool> insert( value_type&& value ); 
            iterator insert( const_iterator hint, value_type&& value ); 

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

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

            std::pair<iterator, bool> insert( node_type&& nh ); 
            iterator insert( const_iterator hint, node_type&& nh ); 

            template <typename...Args> 
            std::pair<iterator, bool> emplace( Args&&... args ); 

            template <typename...Args> 
            iterator emplace_hint( const_iterator hint, Args&&... args ); 

            template <typename SrcHash, typename SrcKeyEqual> 
            void merge( concurrent_unordered_set<T, SrcHash, SrcKeyEqual, Allocator>& source ); 

            template <typename SrcHash, typename SrcKeyEqual> 
            void merge( concurrent_unordered_set<T, SrcHash, SrcKeyEqual, Allocator>&& source ); 

            template <typename SrcHash, typename SrcKeyEqual> 
            void merge( concurrent_unordered_multiset<T, SrcHash, SrcKeyEqual, Allocator>& source ); 

            template <typename SrcHash, typename SrcKeyEqual> 
            void merge( concurrent_unordered_multiset<T, SrcHash, SrcKeyEqual, Allocator>&& source ); 

            // Concurrently unsafe modifiers 
            void clear() noexcept; 

            iterator unsafe_erase( const_iterator pos ); 
            iterator unsafe_erase( iterator pos ); 

            iterator unsafe_erase( const_iterator first, const_iterator last ); 

            size_type unsafe_erase( const key_type& key ); 

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

            node_type unsafe_extract( const_iterator pos ); 
            node_type unsafe_extract( iterator pos ); 

            node_type unsafe_extract( const key_type& key ); 

            template <typename K> 
            node_type unsafe_extract( const K& key ); 

            void swap( concurrent_unordered_set& other ); 

            // Lookup 
            size_type count( const key_type& key ) const; 

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

            iterator find( const key_type& key ); 
            const_iterator find( const key_type& key ) const; 

            template <typename K> 
            iterator find( const K& key ); 

            template <typename K> 
            const_iterator find( const K& key ) const; 

            bool contains( const key_type& key ) const; 

            template <typename K> 
            bool contains( const K& key ) 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; 

            // Bucket interface 
            local_iterator unsafe_begin( size_type n ); 
            const_local_iterator unsafe_begin( size_type n ) const; 
            const_local_iterator unsafe_cbegin( size_type n ) const; 

            local_iterator unsafe_end( size_type n ); 
            const_local_iterator unsafe_end( size_type n ) const; 
            const_local_iterator unsafe_cend( size_type n ) const; 

            size_type unsafe_bucket_count() const; 
            size_type unsafe_max_bucket_bount() const; 

            size_type unsafe_bucket_size( size_type n ) const; 

            size_type unsafe_bucket( const key_type& key ) const; 

            // Hash policy 
            float load_factor() const; 

            float max_load_factor() const; 
            void max_load_factor( float ml ); 

            void rehash( size_type count ); 

            void reserve( size_type count ); 

            // Observers 
            hasher hash_function() const; 
            key_equal key_eq() const; 

            // Parallel iteration 
            range_type range(); 
            const_range_type range() const; 
        }; // class concurrent_unordered_set 
    } // namespace tbb 
} // namespace oneapi

要件:

式 std::allocator_type<Allocator>::destroy(m, val) (m は Allocator タイプのオブジェクト、val は value_type タイプのオブジェクト) は、整数式でなければなりません。メンバー関数は、操作タイプに応じてより厳密な要件を課す場合があります。
Hash タイプは、[hash] ISO C++ 標準の Hash 要件を満たしている必要があります。
KeyEqual タイプは、[algorithms.general] ISO C++ 標準の BinaryPredicate 要件を満たしている必要があります。
Allocator タイプは、[allocator.requirements] ISO C++ 標準の Allocator 要件を満たしている必要があります。

説明

oneapi::tbb::concurrent_unordered_set は、要素がパケットに編成され、順序付けされていない連想シーケンスです。Key オブジェクトのハッシュ関数 Hash の値によって、対応する要素が配置されるパケット番号が決定されます。

修飾 ID Hash::transparent_key_equal が有効でタイプを示す場合、メンバータイプ concurrent_unordered_set::key_equal がこの修飾 ID の値として定義されますが、次の条件に一致するとプログラムは不正な形式となります。

テンプレート・パラメーター KeyEqual が std::equal_to<Key> と異なります。
修飾 ID Hash::transparent_key_equal::is_transparent が無効であるかタイプを示していません。

それ以外では、メンバータイプ concurrent_unordered_set::key_equal は、テンプレート・パラメーター KeyEqual の値として定義されます。

メンバー関数

非メンバー関数

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

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

template <typename T, typename Hash, 
          typename KeyEqual, typename Allocator> 
void swap( concurrent_unordered_set<T, Hash, KeyEqual, Allocator>& lhs, 
           concurrent_unordered_set<T, Hash, KeyEqual, Allocator>& rhs ); 

template <typename T, typename Hash, 
          typename KeyEqual, typename Allocator> 
bool operator==( const concurrent_unordered_set<T, Hash, KeyEqual, Allocator>& lhs, 
                 const concurrent_unordered_set<T, Hash, KeyEqual, Allocator>& rhs ); 

template <typename T, typename Hash, 
          typename KeyEqual, typename Allocator> 
bool operator==( const concurrent_unordered_set<T, Hash, KeyEqual, Allocator>& lhs, 
                 const concurrent_unordered_set<T, Hash, KeyEqual, Allocator>& rhs );

その他

デダクション・ガイド

concurrent_unordered_set

目次

concurrent_unordered_set

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

説明

メンバー関数

非メンバー関数

その他