std::intrusive_list< T > Template-Klassenreferenz

#include <intrusive_list.hpp>

Klassendiagramm für std::intrusive_list< T >:

Zusammengehörigkeiten von std::intrusive_list< T >:

Öffentliche Typen
using	node_type = T
using	value_type = T
using	iterator = intrusive_list_iterator< T *, T & >
using	const_iterator = intrusive_list_iterator< const T *, const T & >
using	size_type = int

Öffentliche Methoden
	intrusive_list ()
void	push_back (value_type *v)
void	push_front (value_type *v)
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
value_type *	front ()
const value_type *	front () const
value_type *	back ()
const value_type *	back () const
iterator	insert (iterator pos, value_type *v)
iterator	erase (iterator it)
iterator	erase (iterator first, iterator last)
void	clear ()
void	pop_back ()
void	pop_front ()
size_type	size () const
bool	empty () const

Öffentliche, statische Methoden
static void	remove (value_type *v)

Geschützte, statische Methoden
static void	link (intrusive_list_node *node, intrusive_list_node *nextNode)
static void	unlink (intrusive_list_node *node)

Geschützte Attribute
intrusive_list_node	m_root

Ausführliche Beschreibung

template<class T>
class std::intrusive_list< T >

Dokumentation der benutzerdefinierten Datentypen

const_iterator

template<class T >

using std::intrusive_list< T >::const_iterator = intrusive_list_iterator<const T*, const T&>

iterator

template<class T >

using std::intrusive_list< T >::iterator = intrusive_list_iterator<T*, T&>

node_type

template<class T >

using std::intrusive_list< T >::node_type = T

size_type

using std::intrusive_list_base::size_type = int

inherited

value_type

template<class T >

using std::intrusive_list< T >::value_type = T

Beschreibung der Konstruktoren und Destruktoren

intrusive_list()

template<class T >

std::intrusive_list< T >::intrusive_list ( )

inline

                                 : intrusive_list_base()
                {
                    intrusive_list_node* testNode((T*)0);
                    static_cast<void>(sizeof(testNode));
                }

Dokumentation der Elementfunktionen

back() [1/2]

template<class T >

value_type* std::intrusive_list< T >::back ( )

inline

                { 
                        return upcast(m_root.prev); 
                }

back() [2/2]

template<class T >

const value_type* std::intrusive_list< T >::back ( ) const

inline

                { 
                        return upcast(m_root.prev); 
                }

begin() [1/2]

template<class T >

iterator std::intrusive_list< T >::begin ( )

inline

                { 
                        return iterator(upcast(m_root.next)); 
                }

begin() [2/2]

template<class T >

const_iterator std::intrusive_list< T >::begin ( ) const

inline

                {
                        return const_iterator(upcast(m_root.next)); 
                }

clear()

template<class T >

void std::intrusive_list< T >::clear ( )

inline

                {
                        erase(begin(), end());
                }

empty()

bool std::intrusive_list_base::empty ( ) const

inlineinherited

        { 
            return !m_root.in_list(); 
        }

end() [1/2]

template<class T >

iterator std::intrusive_list< T >::end ( )

inline

                { 
                        return iterator(upcast(&m_root)); 
                }

end() [2/2]

template<class T >

const_iterator std::intrusive_list< T >::end ( ) const

inline

                { 
                        return const_iterator(upcast(&m_root)); 
                }

erase() [1/2]

template<class T >

iterator std::intrusive_list< T >::erase ( iterator  it )

inline

                {
                    iterator itErase(it);
                    ++it;
                    unlink(itErase.node());
                    return it;
                }

erase() [2/2]

template<class T >

iterator std::intrusive_list< T >::erase ( iterator  first, iterator  last  )

inline

                {
                    while (first != last)
                            first = erase(first);
                    return first;
                }

front() [1/2]

template<class T >

value_type* std::intrusive_list< T >::front ( )

inline

                { 
                        return upcast(m_root.next); 
                }

front() [2/2]

template<class T >

const value_type* std::intrusive_list< T >::front ( ) const

inline

                { 
                        return upcast(m_root.next); 
                }

insert()

template<class T >

iterator std::intrusive_list< T >::insert ( iterator  pos, value_type *  v  )

inline

                {
                    link(v, pos.node());
                    return iterator(v);
                }

link()

void std::intrusive_list_base::link ( intrusive_list_node *  node, intrusive_list_node *  nextNode  )

staticprotectedinherited

    {
        assert(!node->in_list());
        node->prev = nextNode->prev;
        node->prev->next = node;
        nextNode->prev = node;
        node->next = nextNode;
    }

pop_back()

void std::intrusive_list_base::pop_back ( )

inlineinherited

        {
                unlink(m_root.prev);
        }

pop_front()

void std::intrusive_list_base::pop_front ( )

inlineinherited

        {
                unlink(m_root.next);
        }

push_back()

template<class T >

void std::intrusive_list< T >::push_back ( value_type *  v )

inline

                {               
                        link(v, &m_root);
                }

push_front()

template<class T >

void std::intrusive_list< T >::push_front ( value_type *  v )

inline

                {
                    link(v, m_root.next);
                }

remove()

template<class T >

static void std::intrusive_list< T >::remove ( value_type *  v )

inlinestatic

                {
                        unlink(v);
                }

size()

intrusive_list_base::size_type std::intrusive_list_base::size ( ) const

inherited

    {
        size_type numNodes(0);
        const intrusive_list_node* iter = &m_root;
        do
        {
            iter = iter->next;
            ++numNodes;
        } while (iter != &m_root);
        return numNodes - 1;
    }

unlink()

void std::intrusive_list_base::unlink ( intrusive_list_node *  node )

staticprotectedinherited

    {
        assert(node->in_list());
        node->prev->next = node->next;
        node->next->prev = node->prev;
        node->next = node->prev = node;
    }

Dokumentation der Datenelemente

m_root

intrusive_list_node std::intrusive_list_base::m_root

protectedinherited

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/intrusive_list.hpp