Construction, destruction, copying

Empty container constructors

enumerable_thread_specific();

Constructs an enumerable_thread_specific where each thread-local element will be default-constructed.

template<typename Finit> explicit enumerable_thread_specific( Finit finit );

Constructs an enumerable_thread_specific such that any thread-local element will be created by copying the result of finit().

Note

The expression finit() must be safe to evaluate concurrently by multiple threads. It is evaluated each time a thread-local element is created.

explicit enumerable_thread_specific( const T& exemplar );

Constructs an enumerable_thread_specific where each thread-local element will be copy-constructed from exemplar.

explicit enumerable_thread_specific( T&& exemplar );

Constructs an enumerable_thread_specific object, move constructor of T can be used to store exemplar internally, however thread-local elements are always copy-constructed.

template <typename... Args> enumerable_thread_specific( Args&&... args );

Constructs enumerable_thread_specific such that any thread-local element will be constructed by invoking T(args...).

Note

This constructor does not participate in overload resolution if the type of the first argument in args... is T, or enumerable_thread_specific<T>, or foo() is a valid expression for a value foo of that type.

Copying 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 );

Constructs an enumerable_thread_specific as a copy of other. The values are copy-constructed from the values in other and have same thread correspondence.

Moving constructors

enumerable_thread_specific ( enumerable_thread_specific&& other )

Constructs an enumerable_thread_specific by moving the content of other intact. other is left in an unspecified state, but can be safely destroyed.

template<typename Alloc, ets_key_usage_type Cachetype> enumerable_thread_specific( enumerable_thread_specific <T, Alloc, Cachetype>&& other )

Constructs an enumerable_thread_specific using per-element move construction from the values in other, and keeping their thread correspondence. other is left in an unspecified state, but can be safely destroyed.

Destructor

~enumerable_thread_specific()

Destroys all elements in *this. Destroys any native TLS keys that were created for this instance.

Assignment operators

enumerable_thread_specific& operator=( const enumerable_thread_specific& other );

Copies the content of other to *this. Returns a reference to this*.

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

Copies the content of other to *this. Returns a reference to this*.

Note

The allocator and key usage specialization is unchanged by this call.

enumerable_thread_specific& operator=( enumerable_thread_specific&& other );

Moves the content of other to *this intact. An other is left in an unspecified state, but can be safely destroyed. Returns a reference to this*.

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

Moves the content of other to *this using per-element move construction and keeping thread correspondence. An other is left in an unspecified state, but can be safely destroyed. Returns a reference to this*.

Note

The allocator and key usage specialization is unchanged by this call.