std::fixed_list< T, TCapacity > Template-Klassenreferenz

#include <fixed_list.hpp>

Öffentliche Typen
using	index_type = index_type_selector::index_type
using	value_type = T
using	size_type = int
using	iterator = node_iterator< node *, T *, T & >
using	const_iterator = node_iterator< const node *, const T *, const T & >

Öffentliche Methoden
	fixed_list ()
template<class InputIterator >
	fixed_list (InputIterator first, InputIterator last)
	fixed_list (const fixed_list &rhs)
	fixed_list (e_noinitialize)
	~fixed_list ()
fixed_list &	operator= (const fixed_list &rhs)
iterator	begin ()
const_iterator	begin () const
iterator	end ()
const_iterator	end () const
const T &	front () const
T &	front ()
const T &	back () const
T &	back ()
void	push_front (const T &value)
void	pop_front ()
void	push_back (const T &value)
void	pop_back ()
iterator	insert (iterator pos, const T &value)
iterator	erase (iterator it)
iterator	erase (iterator first, iterator last)
template<class InputIterator >
void	assign (InputIterator first, InputIterator last)
void	clear ()
bool	empty () const
size_type	size () const

Ausführliche Beschreibung

template<typename T, size_t TCapacity>
class std::fixed_list< T, TCapacity >

Dokumentation der benutzerdefinierten Datentypen

const_iterator

template<typename T , size_t TCapacity>

using std::fixed_list< T, TCapacity >::const_iterator = node_iterator<const node*, const T*, const T&>

index_type

template<typename T , size_t TCapacity>

using std::fixed_list< T, TCapacity >::index_type = index_type_selector::index_type

iterator

template<typename T , size_t TCapacity>

using std::fixed_list< T, TCapacity >::iterator = node_iterator<node*, T*, T&>

size_type

template<typename T , size_t TCapacity>

using std::fixed_list< T, TCapacity >::size_type = int

value_type

template<typename T , size_t TCapacity>

using std::fixed_list< T, TCapacity >::value_type = T

Beschreibung der Konstruktoren und Destruktoren

fixed_list() [1/4]

template<typename T , size_t TCapacity>

std::fixed_list< T, TCapacity >::fixed_list ( )

inline

                 : m_num_nodes(0) {
            init_free_indices();
            get_root()->reset();
    }

fixed_list() [2/4]

template<typename T , size_t TCapacity>

template<class InputIterator >

std::fixed_list< T, TCapacity >::fixed_list ( InputIterator  first, InputIterator  last  )

inline

                                                            {
            get_root()->reset();
            assign(first, last);
    }

fixed_list() [3/4]

template<typename T , size_t TCapacity>

std::fixed_list< T, TCapacity >::fixed_list ( const fixed_list< T, TCapacity > &  rhs )

inline

                                      {
            get_root()->reset();
            copy(rhs, int_to_type<has_trivial_copy<T>::value>());
    }

fixed_list() [4/4]

template<typename T , size_t TCapacity>

std::fixed_list< T, TCapacity >::fixed_list ( e_noinitialize  )

inlineexplicit

                                        {
        }

~fixed_list()

template<typename T , size_t TCapacity>

std::fixed_list< T, TCapacity >::~fixed_list ( )

inline

                  {
            clear();
    }

Dokumentation der Elementfunktionen

assign()

template<typename T , size_t TCapacity>

template<class InputIterator >

void std::fixed_list< T, TCapacity >::assign ( InputIterator  first, InputIterator  last  )

inline

                                                             {
            clear();
            while (first != last) {
                push_back(*first);
                ++first;
            }
    }

back() [1/2]

template<typename T , size_t TCapacity>

const T& std::fixed_list< T, TCapacity >::back ( ) const

inline

            { assert(!empty()); return get_prev(get_root())->value; }

back() [2/2]

template<typename T , size_t TCapacity>

T& std::fixed_list< T, TCapacity >::back ( )

inline

            { assert(!empty()); return get_prev(get_root())->value; }

begin() [1/2]

template<typename T , size_t TCapacity>

iterator std::fixed_list< T, TCapacity >::begin ( )

inline

            { return iterator(get_next(get_root()), this); }

begin() [2/2]

template<typename T , size_t TCapacity>

const_iterator std::fixed_list< T, TCapacity >::begin ( ) const

inline

            { return const_iterator(get_next(get_root()), this); }

clear()

template<typename T , size_t TCapacity>

void std::fixed_list< T, TCapacity >::clear ( )

inline

                 {
            node* root = get_root();
            node* iter = get_next(root);
            while (iter != root) {
                node* next = get_next(iter);
                destruct_node(iter);
                iter = next;
            }
            root->reset();
            m_num_nodes = 0;
            init_free_indices();
    }

empty()

template<typename T , size_t TCapacity>

bool std::fixed_list< T, TCapacity >::empty ( ) const

inline

            { return m_num_nodes == 0; }

end() [1/2]

template<typename T , size_t TCapacity>

iterator std::fixed_list< T, TCapacity >::end ( )

inline

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

end() [2/2]

template<typename T , size_t TCapacity>

const_iterator std::fixed_list< T, TCapacity >::end ( ) const

inline

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

erase() [1/2]

template<typename T , size_t TCapacity>

iterator std::fixed_list< T, TCapacity >::erase ( iterator  it )

inline

                                {
            assert(!empty());
            assert(it.node()->in_list());
            assert(it.list() == this);
            iterator it_erase(it);
            ++it;
            node* erase_node = it_erase.node();
            m_free_indices[++m_free_index_top] = erase_node->index;
            unlink(erase_node);
            destruct_node(erase_node);
            --m_num_nodes;
            return it;
    }

erase() [2/2]

template<typename T , size_t TCapacity>

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

inline

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

front() [1/2]

template<typename T , size_t TCapacity>

const T& std::fixed_list< T, TCapacity >::front ( ) const

inline

            { assert(!empty()); return get_next(get_root())->value; }

front() [2/2]

template<typename T , size_t TCapacity>

T& std::fixed_list< T, TCapacity >::front ( )

inline

            { assert(!empty()); return get_next(get_root())->value; }

insert()

template<typename T , size_t TCapacity>

iterator std::fixed_list< T, TCapacity >::insert ( iterator  pos, const T &  value  )

inline

                                                  {
            assert(m_free_index_top > 0);
            const int index = m_free_indices[m_free_index_top--];
            node* new_node = construct_node(value, index);
            link_before(new_node, pos.node());
            ++m_num_nodes;
            return iterator(new_node, this);
    }

operator=()

template<typename T , size_t TCapacity>

fixed_list& std::fixed_list< T, TCapacity >::operator= ( const fixed_list< T, TCapacity > &  rhs )

inline

                                                 {
            if (this != &rhs) {
                copy(rhs, int_to_type<has_trivial_copy<T>::value>());
            }
            return *this;
    }

pop_back()

template<typename T , size_t TCapacity>

void std::fixed_list< T, TCapacity >::pop_back ( )

inline

                           {
            assert(!empty());
            node* back_node = get_prev(get_root());
            m_free_indices[++m_free_index_top] = back_node->index;
            unlink(back_node);
            destruct_node(back_node);
            --m_num_nodes;
    }

pop_front()

template<typename T , size_t TCapacity>

void std::fixed_list< T, TCapacity >::pop_front ( )

inline

                            {
            assert(!empty());
            node* front_node = get_next(get_root());
            m_free_indices[++m_free_index_top] = front_node->index;
            unlink(front_node);
            destruct_node(front_node);
            --m_num_nodes;
    }

push_back()

template<typename T , size_t TCapacity>

void std::fixed_list< T, TCapacity >::push_back ( const T &  value )

inline

                                   {
            assert(m_free_index_top > 0);       // 0 is root
            const int index = m_free_indices[m_free_index_top--];
            node* new_node = construct_node(value, index);
            ++m_num_nodes;
            assert(m_num_nodes <= TCapacity + 1);
            link_before(new_node, get_root());
    }

push_front()

template<typename T , size_t TCapacity>

void std::fixed_list< T, TCapacity >::push_front ( const T &  value )

inline

                                    {
            assert(m_free_index_top > 0);       // 0 is root
            const int index = m_free_indices[m_free_index_top--];
            node* new_node = construct_node(value, index);
            ++m_num_nodes;
            assert(m_num_nodes <= TCapacity);
            link_before(new_node, get_next(get_root()));
    }

size()

template<typename T , size_t TCapacity>

size_type std::fixed_list< T, TCapacity >::size ( ) const

inline

            { return m_num_nodes; }

---

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

• include/fixed_list.hpp