std::intrusive_slist< T > Template-Klassenreferenz

#include <intrusive_slist.hpp>

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

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

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

Öffentliche Methoden
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
iterator	insert (iterator pos, value_type *v)
iterator	insert_after (iterator pos, value_type *v)
iterator	erase (iterator pos)
void	erase_after (iterator pos)
iterator	erase (iterator first, iterator last)
void	clear ()
void	pop_front ()
size_type	size () const
bool	empty () const

Öffentliche, statische Methoden
static iterator	previous (iterator nextIt)
static const_iterator	previous (const_iterator nextIt)
static iterator	get_iterator (value_type *v)
static const_iterator	get_iterator (const value_type *v)
static void	remove (value_type *v)

Geschützte, statische Methoden
static void	link_after (intrusive_slist_node *node, intrusive_slist_node *prevNode)
static void	unlink_after (intrusive_slist_node *node)

Geschützte Attribute
intrusive_slist_node	m_root

Ausführliche Beschreibung

template<class T>
class std::intrusive_slist< T >

Dokumentation der benutzerdefinierten Datentypen

const_iterator

template<class T >

using std::intrusive_slist< T >::const_iterator = intrusive_slist_iterator<const T*, const T&>

iterator

template<class T >

using std::intrusive_slist< T >::iterator = intrusive_slist_iterator<T*, T&>

node_type

template<class T >

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

size_type

typedef int std::intrusive_slist_base::size_type

inherited

value_type

template<class T >

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

Dokumentation der Elementfunktionen

begin() [1/2]

template<class T >

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

inline

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

begin() [2/2]

template<class T >

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

inline

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

clear()

template<class T >

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

inline

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

empty()

bool std::intrusive_slist_base::empty ( ) const

inlineinherited

            { 
                    return !m_root.in_list(); 
            }

end() [1/2]

template<class T >

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

inline

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

end() [2/2]

template<class T >

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

inline

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

erase() [1/2]

template<class T >

iterator std::intrusive_slist< T >::erase ( iterator  pos )

inline

            {
                pos = previous(pos);
                erase_after(pos);
                return ++pos;
            }

erase() [2/2]

template<class T >

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

inline

            {
                if (first != last)
                {
                    while (first.next() != last.node())
                            erase_after(first);
                    erase_after(previous(first));
                }
                return first;
            }

erase_after()

template<class T >

void std::intrusive_slist< T >::erase_after ( iterator  pos )

inline

            {
                    unlink_after(pos.node());
            }

front() [1/2]

template<class T >

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

inline

            { 
                    return upcast(m_root.next); 
            }

front() [2/2]

template<class T >

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

inline

            { 
                    return upcast(m_root.next); 
            }

get_iterator() [1/2]

template<class T >

static iterator std::intrusive_slist< T >::get_iterator ( value_type *  v )

inlinestatic

            {
                assert(v->in_list());
                return iterator(v);
            }

get_iterator() [2/2]

template<class T >

static const_iterator std::intrusive_slist< T >::get_iterator ( const value_type *  v )

inlinestatic

            {
                assert(v->in_list());
                return const_iterator(v);
            }

insert()

template<class T >

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

inline

            {
                    return insert_after(previous(pos), v);
            }

insert_after()

template<class T >

iterator std::intrusive_slist< T >::insert_after ( iterator  pos, value_type *  v  )

inline

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

link_after()

void std::intrusive_slist_base::link_after ( intrusive_slist_node *  node, intrusive_slist_node *  prevNode  )

staticprotectedinherited

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

pop_front()

void std::intrusive_slist_base::pop_front ( )

inlineinherited

            {
                    unlink_after(&m_root);
            }

previous() [1/2]

template<class T >

static iterator std::intrusive_slist< T >::previous ( iterator  nextIt )

inlinestatic

            {
                assert(nextIt.node()->in_list());
                iterator prevIt = nextIt;
                while (nextIt.node() != prevIt.next())
                        ++prevIt;
                return prevIt;
            }

previous() [2/2]

template<class T >

static const_iterator std::intrusive_slist< T >::previous ( const_iterator  nextIt )

inlinestatic

            {
                assert(nextIt.node()->in_list());
                const_iterator prevIt = nextIt;
                while (nextIt.node() != prevIt.next())
                        ++prevIt;
                return prevIt;
            }

push_front()

template<class T >

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

inline

            {
                    link_after(v, &m_root);
            }

remove()

template<class T >

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

inlinestatic

            {
                    unlink(v);
            }

size()

intrusive_slist_base::size_type std::intrusive_slist_base::size ( ) const

inherited

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

unlink_after()

void std::intrusive_slist_base::unlink_after ( intrusive_slist_node *  node )

staticprotectedinherited

    {
        assert(node->in_list());
        intrusive_slist_node* thisNode = node->next;
        node->next = thisNode->next;
        thisNode->next = thisNode;
    }

Dokumentation der Datenelemente

m_root

intrusive_slist_node std::intrusive_slist_base::m_root

protectedinherited

---

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

• include/intrusive_slist.hpp