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

namespace oneapi { 
namespace tbb { 

    enum ets_key_usage_type { ets_key_per_instance, ets_no_key, ets_suspend_aware }; 
    template <typename T, typename Allocator=cache_aligned_allocator<T>, ets_key_usage_type ETS_key_type=ets_no_key > 
    class enumerable_thread_specific { 
    public:        // Basic types 
        using value_type = T; 
        using reference = T&; 
        using const_reference = const T&; 
        using pointer = T*; 
        using size_type = /* implementation-defined */; 
        using difference_type = /* implementation-defined */; 
        using allocator_type = Allocator; 
        // Iterator types 
        using iterator = /* implementation-defined */; 
        using const_iterator = /* implementation-defined */; 
        // Parallel range types 
        using range_type = /* implementation-defined */; 
        using const_range_type = /* implementation-defined */; 
        // Construction 
        enumerable_thread_specific(); 
        template <typename Finit> explicit enumerable_thread_specific( Finit finit ); 
        explicit enumerable_thread_specific( const T& exemplar ); 
        explicit enumerable_thread_specific( T&& exemplar ); 
        template <typename...Args> enumerable_thread_specific( Args&&... args ); 
        // Destruction 
        ~enumerable_thread_specific(); 

        // Copy constructors enumerable_thread_specific( const enumerable_thread_specific& other); 
        template<typename Alloc, ets_key_usage_type Cachetype> 
        enumerable_thread_specific( const enumerable_thread_specific<T, Alloc, Cachetype>& other); 

        // Copy assignments 
        enumerable_thread_specific& operator=( const enumerable_thread_specific& other ); 
        template<typename Alloc, ets_key_usage_type Cachetype> 
        enumerable_thread_specific& operator=( const enumerable_thread_specific<T, Alloc, Cachetype>& other ); 

        // Move constructors 
        enumerable_thread_specific( enumerable_thread_specific&& other); 
        template<typename Alloc, ets_key_usage_type Cachetype> 
        enumerable_thread_specific( enumerable_thread_specific<T, Alloc, Cachetype>&& other); 

        // Move assignments 
        enumerable_thread_specific& operator=( enumerable_thread_specific&& other ); 
        template<typename Alloc, ets_key_usage_type Cachetype> 
        enumerable_thread_specific& operator=( enumerable_thread_specific<T, Alloc, Cachetype>&& other ); 

        // Other whole container operations 
        void clear(); 

        // Concurrent operations 
        reference local(); 
        reference local( bool& exists ); 
        size_type size() const; 
        bool empty() const; 

        // Combining 
        template<typename BinaryFunc> T combine( BinaryFunc f ); 
        template<typename UnaryFunc> void combine_each( UnaryFunc f ); 

        // Parallel iteration 
        range_type range( size_t grainsize=1 ); 
        const_range_type range( size_t grainsize=1 ) const; 

        // Iterators 
        iterator begin(); 
        iterator end(); 
        const_iterator begin() const; 
        const_iterator end() const; 
    }; 
} // namespace tbb 
} // namespace oneapi