tbb::interface5::internal::split_ordered_list< T, Allocator > Class Template Reference

#include <_concurrent_unordered_impl.h>

Inheritance diagram for tbb::interface5::internal::split_ordered_list< T, Allocator >:

Collaboration diagram for tbb::interface5::internal::split_ordered_list< T, Allocator >:

Classes
struct	node

Public Types
typedef split_ordered_list< T, Allocator >	self_type
typedef tbb::internal::allocator_rebind< Allocator, T >::type	allocator_type
typedef node *	nodeptr_t
typedef tbb::internal::allocator_traits< allocator_type >::value_type	value_type
typedef tbb::internal::allocator_traits< allocator_type >::size_type	size_type
typedef tbb::internal::allocator_traits< allocator_type >::difference_type	difference_type
typedef tbb::internal::allocator_traits< allocator_type >::pointer	pointer
typedef tbb::internal::allocator_traits< allocator_type >::const_pointer	const_pointer
typedef value_type &	reference
typedef const value_type &	const_reference
typedef solist_iterator< self_type, const value_type >	const_iterator
typedef solist_iterator< self_type, value_type >	iterator
typedef flist_iterator< self_type, const value_type >	raw_const_iterator
typedef flist_iterator< self_type, value_type >	raw_iterator

Public Member Functions
nodeptr_t	create_node (sokey_t order_key)
template<typename Arg >
nodeptr_t	create_node (sokey_t order_key, __TBB_FORWARDING_REF(Arg) t, tbb::internal::true_type=tbb::internal::true_type())
template<typename Arg >
nodeptr_t	create_node (sokey_t, __TBB_FORWARDING_REF(Arg), tbb::internal::false_type)
template<typename __TBB_PARAMETER_PACK Args>
nodeptr_t	create_node_v (__TBB_FORWARDING_REF(Args) __TBB_PARAMETER_PACK args)
	split_ordered_list (allocator_type a=allocator_type())
	~split_ordered_list ()
allocator_type	get_allocator () const
void	clear ()
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
const_iterator	cbegin () const
const_iterator	cend () const
bool	empty () const
size_type	size () const
size_type	max_size () const
void	swap (self_type &other)
raw_iterator	raw_begin ()
raw_const_iterator	raw_begin () const
raw_iterator	raw_end ()
raw_const_iterator	raw_end () const
iterator	get_iterator (raw_iterator it)
const_iterator	get_iterator (raw_const_iterator it) const
raw_iterator	get_iterator (raw_const_iterator it)
iterator	first_real_iterator (raw_iterator it)
const_iterator	first_real_iterator (raw_const_iterator it) const
void	destroy_node (nodeptr_t pnode)
std::pair< iterator, bool >	try_insert (raw_iterator it, raw_iterator next, nodeptr_t pnode, size_type *new_count)
raw_iterator	insert_dummy (raw_iterator it, sokey_t order_key)
void	erase_node (raw_iterator previous, raw_const_iterator &where)
iterator	erase_node (raw_iterator previous, const_iterator where)
void	move_all (self_type &source)

Static Public Member Functions
static sokey_t	get_order_key (const raw_const_iterator &it)
static sokey_t	get_safe_order_key (const raw_const_iterator &it)
static iterator	get_iterator (const_iterator it)
static nodeptr_t	try_insert_atomic (nodeptr_t previous, nodeptr_t new_node, nodeptr_t current_node)

Private Member Functions
void	check_range (raw_iterator first, raw_iterator last)
void	check_range ()

Private Attributes
tbb::internal::allocator_rebind< allocator_type, node >::type	my_node_allocator
size_type	my_element_count
nodeptr_t	my_head

Friends
template<typename Traits >
class	concurrent_unordered_base

Detailed Description

template<typename T, typename Allocator>
class tbb::interface5::internal::split_ordered_list< T, Allocator >

Definition at line 56 of file _concurrent_unordered_impl.h.

Member Typedef Documentation

allocator_type

template<typename T, typename Allocator>

typedef tbb::internal::allocator_rebind<Allocator, T>::type tbb::interface5::internal::split_ordered_list< T, Allocator >::allocator_type

Definition at line 190 of file _concurrent_unordered_impl.h.

const_iterator

template<typename T, typename Allocator>

typedef solist_iterator<self_type, const value_type> tbb::interface5::internal::split_ordered_list< T, Allocator >::const_iterator

Definition at line 204 of file _concurrent_unordered_impl.h.

const_pointer

template<typename T, typename Allocator>

typedef tbb::internal::allocator_traits<allocator_type>::const_pointer tbb::interface5::internal::split_ordered_list< T, Allocator >::const_pointer

Definition at line 199 of file _concurrent_unordered_impl.h.

const_reference

template<typename T, typename Allocator>

typedef const value_type& tbb::interface5::internal::split_ordered_list< T, Allocator >::const_reference

Definition at line 202 of file _concurrent_unordered_impl.h.

difference_type

template<typename T, typename Allocator>

typedef tbb::internal::allocator_traits<allocator_type>::difference_type tbb::interface5::internal::split_ordered_list< T, Allocator >::difference_type

Definition at line 197 of file _concurrent_unordered_impl.h.

iterator

template<typename T, typename Allocator>

typedef solist_iterator<self_type, value_type> tbb::interface5::internal::split_ordered_list< T, Allocator >::iterator

Definition at line 205 of file _concurrent_unordered_impl.h.

nodeptr_t

template<typename T, typename Allocator>

typedef node* tbb::interface5::internal::split_ordered_list< T, Allocator >::nodeptr_t

Definition at line 192 of file _concurrent_unordered_impl.h.

pointer

template<typename T, typename Allocator>

typedef tbb::internal::allocator_traits<allocator_type>::pointer tbb::interface5::internal::split_ordered_list< T, Allocator >::pointer

Definition at line 198 of file _concurrent_unordered_impl.h.

raw_const_iterator

template<typename T, typename Allocator>

typedef flist_iterator<self_type, const value_type> tbb::interface5::internal::split_ordered_list< T, Allocator >::raw_const_iterator

Definition at line 206 of file _concurrent_unordered_impl.h.

raw_iterator

template<typename T, typename Allocator>

typedef flist_iterator<self_type, value_type> tbb::interface5::internal::split_ordered_list< T, Allocator >::raw_iterator

Definition at line 207 of file _concurrent_unordered_impl.h.

reference

template<typename T, typename Allocator>

typedef value_type& tbb::interface5::internal::split_ordered_list< T, Allocator >::reference

Definition at line 201 of file _concurrent_unordered_impl.h.

self_type

template<typename T, typename Allocator>

typedef split_ordered_list<T, Allocator> tbb::interface5::internal::split_ordered_list< T, Allocator >::self_type

Definition at line 188 of file _concurrent_unordered_impl.h.

size_type

template<typename T, typename Allocator>

typedef tbb::internal::allocator_traits<allocator_type>::size_type tbb::interface5::internal::split_ordered_list< T, Allocator >::size_type

Definition at line 196 of file _concurrent_unordered_impl.h.

value_type

template<typename T, typename Allocator>

typedef tbb::internal::allocator_traits<allocator_type>::value_type tbb::interface5::internal::split_ordered_list< T, Allocator >::value_type

Definition at line 195 of file _concurrent_unordered_impl.h.

Constructor & Destructor Documentation

split_ordered_list()

template<typename T, typename Allocator>

tbb::interface5::internal::split_ordered_list< T, Allocator >::split_ordered_list ( allocator_type  a = allocator_type() )

inline

Definition at line 306 of file _concurrent_unordered_impl.h.

       : my_node_allocator(a), my_element_count(0)
    {
        // Immediately allocate a dummy node with order key of 0. This node
        // will always be the head of the list.
        my_head = create_node(sokey_t(0));
    }

~split_ordered_list()

template<typename T, typename Allocator>

tbb::interface5::internal::split_ordered_list< T, Allocator >::~split_ordered_list ( )

inline

Definition at line 314 of file _concurrent_unordered_impl.h.

    {
        // Clear the list
        clear();

        // Remove the head element which is not cleared by clear()
        nodeptr_t pnode = my_head;
        my_head = NULL;

        __TBB_ASSERT(pnode != NULL && pnode->my_next == NULL, "Invalid head list node");

        destroy_node(pnode);
    }

Member Function Documentation

begin() [1/2]

template<typename T, typename Allocator>

iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::begin ( )

inline

Definition at line 354 of file _concurrent_unordered_impl.h.

                     {
        return first_real_iterator(raw_begin());
    }

begin() [2/2]

template<typename T, typename Allocator>

const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::begin ( ) const

inline

Definition at line 359 of file _concurrent_unordered_impl.h.

                                 {
        return first_real_iterator(raw_begin());
    }

cbegin()

template<typename T, typename Allocator>

const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::cbegin ( ) const

inline

Definition at line 371 of file _concurrent_unordered_impl.h.

                                  {
        return (((const self_type *)this)->begin());
    }

cend()

template<typename T, typename Allocator>

const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::cend ( ) const

inline

Definition at line 375 of file _concurrent_unordered_impl.h.

                                {
        return (((const self_type *)this)->end());
    }

check_range() [1/2]

template<typename T, typename Allocator>

void tbb::interface5::internal::split_ordered_list< T, Allocator >::check_range ( raw_iterator  first, raw_iterator  last  )

inlineprivate

Definition at line 625 of file _concurrent_unordered_impl.h.

    {
#if TBB_USE_ASSERT
        for (raw_iterator it = first; it != last; ++it)
        {
            raw_iterator next = it;
            ++next;

            __TBB_ASSERT(next == raw_end() || get_order_key(next) >= get_order_key(it), "!!! List order inconsistency !!!");
        }
#else
        tbb::internal::suppress_unused_warning(first, last);
#endif
    }

check_range() [2/2]

template<typename T, typename Allocator>

void tbb::interface5::internal::split_ordered_list< T, Allocator >::check_range ( )

inlineprivate

Definition at line 639 of file _concurrent_unordered_impl.h.

    {
#if TBB_USE_ASSERT
        check_range( raw_begin(), raw_end() );
#endif
    }

clear()

template<typename T, typename Allocator>

void tbb::interface5::internal::split_ordered_list< T, Allocator >::clear ( )

inline

Definition at line 334 of file _concurrent_unordered_impl.h.

                 {
        nodeptr_t pnext;
        nodeptr_t pnode = my_head;

        __TBB_ASSERT(my_head != NULL, "Invalid head list node");
        pnext = pnode->my_next;
        pnode->my_next = NULL;
        pnode = pnext;

        while (pnode != NULL)
        {
            pnext = pnode->my_next;
            destroy_node(pnode);
            pnode = pnext;
        }

        my_element_count = 0;
    }

create_node() [1/3]

template<typename T, typename Allocator>

nodeptr_t tbb::interface5::internal::split_ordered_list< T, Allocator >::create_node ( sokey_t  order_key )

inline

Definition at line 258 of file _concurrent_unordered_impl.h.

                                             {
        nodeptr_t pnode = my_node_allocator.allocate(1);
        pnode->init(order_key);
        return (pnode);
    }

create_node() [2/3]

template<typename T, typename Allocator>

template<typename Arg >

nodeptr_t tbb::interface5::internal::split_ordered_list< T, Allocator >::create_node ( sokey_t  order_key, __TBB_FORWARDING_REF(Arg)  t, tbb::internal::true_type  = tbb::internal::true_type()  )

inline

Definition at line 266 of file _concurrent_unordered_impl.h.

                                                                       {
        nodeptr_t pnode = my_node_allocator.allocate(1);

        //TODO: use RAII scoped guard instead of explicit catch
        __TBB_TRY {
            new(static_cast<void*>(&pnode->my_element)) T(tbb::internal::forward<Arg>(t));
            pnode->init(order_key);
        } __TBB_CATCH(...) {
            my_node_allocator.deallocate(pnode, 1);
            __TBB_RETHROW();
        }

        return (pnode);
    }

create_node() [3/3]

template<typename T, typename Allocator>

template<typename Arg >

nodeptr_t tbb::interface5::internal::split_ordered_list< T, Allocator >::create_node ( sokey_t  , __TBB_FORWARDING_REF(Arg)  , tbb::internal::false_type    )

inline

Definition at line 284 of file _concurrent_unordered_impl.h.

                                                 {
        __TBB_ASSERT(false, "This compile-time helper should never get called");
        return nodeptr_t();
    }

create_node_v()

template<typename T, typename Allocator>

template<typename __TBB_PARAMETER_PACK Args>

nodeptr_t tbb::interface5::internal::split_ordered_list< T, Allocator >::create_node_v ( __TBB_FORWARDING_REF(Args) __TBB_PARAMETER_PACK  args )

inline

Definition at line 292 of file _concurrent_unordered_impl.h.

                                                                                  {
        nodeptr_t pnode = my_node_allocator.allocate(1);

        //TODO: use RAII scoped guard instead of explicit catch
        __TBB_TRY {
            new(static_cast<void*>(&pnode->my_element)) T(__TBB_PACK_EXPANSION(tbb::internal::forward<Args>(args)));
        } __TBB_CATCH(...) {
            my_node_allocator.deallocate(pnode, 1);
            __TBB_RETHROW();
        }

        return (pnode);
    }

destroy_node()

template<typename T, typename Allocator>

void tbb::interface5::internal::split_ordered_list< T, Allocator >::destroy_node ( nodeptr_t  pnode )

inline

Definition at line 483 of file _concurrent_unordered_impl.h.

                                       {
        if (!pnode->is_dummy()) my_node_allocator.destroy(pnode);
        my_node_allocator.deallocate(pnode, 1);
    }

empty()

template<typename T, typename Allocator>

bool tbb::interface5::internal::split_ordered_list< T, Allocator >::empty ( ) const

inline

Definition at line 380 of file _concurrent_unordered_impl.h.

                       {
        return (my_element_count == 0);
    }

end() [1/2]

template<typename T, typename Allocator>

iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::end ( )

inline

Definition at line 363 of file _concurrent_unordered_impl.h.

                   {
        return (iterator(0, this));
    }

end() [2/2]

template<typename T, typename Allocator>

const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::end ( ) const

inline

Definition at line 367 of file _concurrent_unordered_impl.h.

                               {
        return (const_iterator(0, this));
    }

erase_node() [1/2]

template<typename T, typename Allocator>

void tbb::interface5::internal::split_ordered_list< T, Allocator >::erase_node ( raw_iterator  previous, raw_const_iterator &  where  )

inline

Definition at line 572 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::move_all().

    {
        nodeptr_t pnode = (where++).get_node_ptr();
        nodeptr_t prevnode = previous.get_node_ptr();
        __TBB_ASSERT(prevnode->my_next == pnode, "Erase must take consecutive iterators");
        prevnode->my_next = pnode->my_next;

        destroy_node(pnode);
    }

Here is the caller graph for this function:

erase_node() [2/2]

template<typename T, typename Allocator>

iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::erase_node ( raw_iterator  previous, const_iterator  where  )

inline

Definition at line 583 of file _concurrent_unordered_impl.h.

    {
        raw_const_iterator it = where;
        erase_node(previous, it);
        my_element_count--;

        return get_iterator(first_real_iterator(it));
    }

first_real_iterator() [1/2]

template<typename T, typename Allocator>

iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::first_real_iterator ( raw_iterator  it )

inline

Definition at line 462 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::set_midpoint().

    {
        // Skip all dummy, internal only iterators
        while (it != raw_end() && it.get_node_ptr()->is_dummy())
            ++it;

        return iterator(it.get_node_ptr(), this);
    }

Here is the caller graph for this function:

first_real_iterator() [2/2]

template<typename T, typename Allocator>

const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::first_real_iterator ( raw_const_iterator  it ) const

inline

Definition at line 473 of file _concurrent_unordered_impl.h.

    {
        // Skip all dummy, internal only iterators
        while (it != raw_end() && it.get_node_ptr()->is_dummy())
            ++it;

        return const_iterator(it.get_node_ptr(), this);
    }

get_allocator()

template<typename T, typename Allocator>

allocator_type tbb::interface5::internal::split_ordered_list< T, Allocator >::get_allocator ( ) const

inline

Definition at line 330 of file _concurrent_unordered_impl.h.

                                         {
        return (my_node_allocator);
    }

get_iterator() [1/4]

template<typename T, typename Allocator>

iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::get_iterator ( raw_iterator  it )

inline

Definition at line 438 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::begin(), and tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type::end().

                                           {
        __TBB_ASSERT(it.get_node_ptr() == NULL || !it.get_node_ptr()->is_dummy(), "Invalid user node (dummy)");
        return iterator(it.get_node_ptr(), this);
    }

Here is the caller graph for this function:

get_iterator() [2/4]

template<typename T, typename Allocator>

const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::get_iterator ( raw_const_iterator  it ) const

inline

Definition at line 445 of file _concurrent_unordered_impl.h.

                                                             {
        __TBB_ASSERT(it.get_node_ptr() == NULL || !it.get_node_ptr()->is_dummy(), "Invalid user node (dummy)");
        return const_iterator(it.get_node_ptr(), this);
    }

get_iterator() [3/4]

template<typename T, typename Allocator>

raw_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::get_iterator ( raw_const_iterator  it )

inline

Definition at line 451 of file _concurrent_unordered_impl.h.

                                                     {
        return raw_iterator(it.get_node_ptr());
    }

get_iterator() [4/4]

template<typename T, typename Allocator>

static iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::get_iterator ( const_iterator  it )

inlinestatic

Definition at line 456 of file _concurrent_unordered_impl.h.

                                                    {
        return iterator(it.my_node_ptr, it.my_list_ptr);
    }

get_order_key()

template<typename T, typename Allocator>

static sokey_t tbb::interface5::internal::split_ordered_list< T, Allocator >::get_order_key ( const raw_const_iterator &  it )

inlinestatic

Definition at line 427 of file _concurrent_unordered_impl.h.

                                                               {
        return it.get_node_ptr()->get_order_key();
    }

get_safe_order_key()

template<typename T, typename Allocator>

static sokey_t tbb::interface5::internal::split_ordered_list< T, Allocator >::get_safe_order_key ( const raw_const_iterator &  it )

inlinestatic

Definition at line 431 of file _concurrent_unordered_impl.h.

                                                                    {
        if( !it.get_node_ptr() )  return ~sokey_t(0);
        return it.get_node_ptr()->get_order_key();
    }

insert_dummy()

template<typename T, typename Allocator>

raw_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::insert_dummy ( raw_iterator  it, sokey_t  order_key  )

inline

Definition at line 514 of file _concurrent_unordered_impl.h.

    {
        raw_iterator last = raw_end();
        raw_iterator where = it;

        __TBB_ASSERT(where != last, "Invalid head node");

        ++where;

        // Create a dummy element up front, even though it may be discarded (due to concurrent insertion)
        nodeptr_t dummy_node = create_node(order_key);

        for (;;)
        {
            __TBB_ASSERT(it != last, "Invalid head list node");

            // If the head iterator is at the end of the list, or past the point where this dummy
            // node needs to be inserted, then try to insert it.
            if (where == last || get_order_key(where) > order_key)
            {
                __TBB_ASSERT(get_order_key(it) < order_key, "Invalid node order in the list");

                // Try to insert it in the right place
                nodeptr_t inserted_node = try_insert_atomic(it.get_node_ptr(), dummy_node, where.get_node_ptr());

                if (inserted_node == dummy_node)
                {
                    // Insertion succeeded, check the list for order violations
                    check_range(it, where);
                    return raw_iterator(dummy_node);
                }
                else
                {
                    // Insertion failed: either dummy node was inserted by another thread, or
                    // a real element was inserted at exactly the same place as dummy node.
                    // Proceed with the search from the previous location where order key was
                    // known to be larger (note: this is legal only because there is no safe
                    // concurrent erase operation supported).
                    where = it;
                    ++where;
                    continue;
                }
            }
            else if (get_order_key(where) == order_key)
            {
                // Another dummy node with the same value found, discard the new one.
                destroy_node(dummy_node);
                return where;
            }

            // Move the iterator forward
            it = where;
            ++where;
        }

    }

max_size()

template<typename T, typename Allocator>

size_type tbb::interface5::internal::split_ordered_list< T, Allocator >::max_size ( ) const

inline

Definition at line 390 of file _concurrent_unordered_impl.h.

                               {
        return my_node_allocator.max_size();
    }

move_all()

template<typename T, typename Allocator>

void tbb::interface5::internal::split_ordered_list< T, Allocator >::move_all ( self_type &  source )

inline

Definition at line 593 of file _concurrent_unordered_impl.h.

    {
        raw_const_iterator first = source.raw_begin();
        raw_const_iterator last = source.raw_end();

        if (first == last)
            return;

        nodeptr_t previous_node = my_head;
        raw_const_iterator begin_iterator = first++;

        // Move all elements one by one, including dummy ones
        for (raw_const_iterator it = first; it != last;)
        {
            nodeptr_t pnode = it.get_node_ptr();

            nodeptr_t dummy_node = pnode->is_dummy() ? create_node(pnode->get_order_key()) : create_node(pnode->get_order_key(), pnode->my_element);
            previous_node = try_insert_atomic(previous_node, dummy_node, NULL);
            __TBB_ASSERT(previous_node != NULL, "Insertion must succeed");
            raw_const_iterator where = it++;
            source.erase_node(get_iterator(begin_iterator), where);
        }
        check_range();
    }

raw_begin() [1/2]

template<typename T, typename Allocator>

raw_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::raw_begin ( )

inline

Definition at line 410 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::move_all().

                             {
        return raw_iterator(my_head);
    }

Here is the caller graph for this function:

raw_begin() [2/2]

template<typename T, typename Allocator>

raw_const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::raw_begin ( ) const

inline

Definition at line 415 of file _concurrent_unordered_impl.h.

                                         {
        return raw_const_iterator(my_head);
    }

raw_end() [1/2]

template<typename T, typename Allocator>

raw_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::raw_end ( )

inline

Definition at line 419 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::move_all().

                           {
        return raw_iterator(0);
    }

Here is the caller graph for this function:

raw_end() [2/2]

template<typename T, typename Allocator>

raw_const_iterator tbb::interface5::internal::split_ordered_list< T, Allocator >::raw_end ( ) const

inline

Definition at line 423 of file _concurrent_unordered_impl.h.

                                       {
        return raw_const_iterator(0);
    }

size()

template<typename T, typename Allocator>

size_type tbb::interface5::internal::split_ordered_list< T, Allocator >::size ( ) const

inline

Definition at line 385 of file _concurrent_unordered_impl.h.

                           {
        return my_element_count;
    }

swap()

template<typename T, typename Allocator>

void tbb::interface5::internal::split_ordered_list< T, Allocator >::swap ( self_type &  other )

inline

Definition at line 395 of file _concurrent_unordered_impl.h.

    {
        if (this == &other)
        {
            // Nothing to do
            return;
        }

            std::swap(my_element_count, other.my_element_count);
            std::swap(my_head, other.my_head);
    }

try_insert()

template<typename T, typename Allocator>

std::pair<iterator, bool> tbb::interface5::internal::split_ordered_list< T, Allocator >::try_insert ( raw_iterator  it, raw_iterator  next, nodeptr_t  pnode, size_type *  new_count  )

inline

Definition at line 496 of file _concurrent_unordered_impl.h.

    {
        nodeptr_t inserted_node = try_insert_atomic(it.get_node_ptr(), pnode, next.get_node_ptr());

        if (inserted_node == pnode)
        {
            // If the insert succeeded, check that the order is correct and increment the element count
            check_range(it, next);
            *new_count = tbb::internal::as_atomic(my_element_count).fetch_and_increment();
            return std::pair<iterator, bool>(iterator(pnode, this), true);
        }
        else
        {
            return std::pair<iterator, bool>(end(), false);
        }
    }

try_insert_atomic()

template<typename T, typename Allocator>

static nodeptr_t tbb::interface5::internal::split_ordered_list< T, Allocator >::try_insert_atomic ( nodeptr_t  previous, nodeptr_t  new_node, nodeptr_t  current_node  )

inlinestatic

Definition at line 490 of file _concurrent_unordered_impl.h.

                                                                                                       {
        new_node->my_next = current_node;
        return previous->atomic_set_next(new_node, current_node);
    }

Friends And Related Function Documentation

concurrent_unordered_base

template<typename T, typename Allocator>

template<typename Traits >

friend class concurrent_unordered_base

friend

Definition at line 622 of file _concurrent_unordered_impl.h.

Member Data Documentation

my_element_count

template<typename T, typename Allocator>

size_type tbb::interface5::internal::split_ordered_list< T, Allocator >::my_element_count

private

Definition at line 647 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::swap().

my_head

template<typename T, typename Allocator>

nodeptr_t tbb::interface5::internal::split_ordered_list< T, Allocator >::my_head

private

Definition at line 648 of file _concurrent_unordered_impl.h.

Referenced by tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type >::swap().

my_node_allocator

template<typename T, typename Allocator>

tbb::internal::allocator_rebind<allocator_type, node>::type tbb::interface5::internal::split_ordered_list< T, Allocator >::my_node_allocator

private

Definition at line 646 of file _concurrent_unordered_impl.h.

---

The documentation for this class was generated from the following file:

• _concurrent_unordered_impl.h