CommonLibSSE (Parapets fork)
Classes | Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
RE::BSSimpleList< T > Class Template Reference

#include <BSSimpleList.h>

Classes

class  iterator_base
 
struct  Node
 

Public Types

using value_type = T
 
using size_type = std::uint32_t
 
using reference = value_type &
 
using const_reference = const value_type &
 
using iterator = iterator_base< value_type >
 
using const_iterator = iterator_base< const value_type >
 

Public Member Functions

 BSSimpleList ()
 
 BSSimpleList (const BSSimpleList &a_rhs)
 
 BSSimpleList (BSSimpleList &&a_rhs)
 
 ~BSSimpleList ()
 
BSSimpleList & operator= (const BSSimpleList &a_rhs)
 
BSSimpleList & operator= (BSSimpleList &&a_rhs)
 
 TES_HEAP_REDEFINE_NEW ()
 
reference front ()
 
const_reference front () const
 
iterator begin ()
 
const_iterator begin () const
 
const_iterator cbegin () const
 
constexpr iterator end () noexcept
 
constexpr const_iterator end () const noexcept
 
constexpr const_iterator cend () const noexcept
 
bool empty () const
 
void clear ()
 
iterator insert_after (const_iterator a_pos, const_reference a_value)
 
iterator insert_after (const_iterator a_pos, value_type &&a_value)
 
iterator insert_after (const_iterator a_pos, size_type a_count, const_reference a_value)
 
iterator erase_after (const_iterator a_pos)
 
iterator erase_after (const_iterator a_first, const_iterator a_last)
 
void push_front (const_reference a_value)
 
void push_front (value_type &&a_value)
 
template<class... Args>
reference emplace_front (Args &&... a_args)
 
void pop_front ()
 
void resize (size_type a_count)
 
void resize (size_type a_count, const value_type &a_value)
 

Protected Member Functions

constexpr Node * get_head () noexcept
 
constexpr const Node * get_head () const noexcept
 
std::pair< Node *, Node * > alloc_copies (size_type a_count, const_reference a_value)
 
void copy_from (const BSSimpleList &a_rhs)
 
Node * insert_after_impl (Node *a_pos, std::pair< Node *, Node * > a_values)
 
void erase_after_impl (Node *a_head, Node *a_tail)
 
template<class... Args>
void emplace_front_impl (Args &&... a_args)
 
void resize_impl (size_type a_count, const_reference a_value)
 

Protected Attributes

Node _listHead
 

Member Typedef Documentation

◆ const_iterator

template<class T >
using RE::BSSimpleList< T >::const_iterator = iterator_base<const value_type>

◆ const_reference

template<class T >
using RE::BSSimpleList< T >::const_reference = const value_type&

◆ iterator

template<class T >
using RE::BSSimpleList< T >::iterator = iterator_base<value_type>

◆ reference

template<class T >
using RE::BSSimpleList< T >::reference = value_type&

◆ size_type

template<class T >
using RE::BSSimpleList< T >::size_type = std::uint32_t

◆ value_type

template<class T >
using RE::BSSimpleList< T >::value_type = T

Constructor & Destructor Documentation

◆ BSSimpleList() [1/3]

template<class T >
RE::BSSimpleList< T >::BSSimpleList ( )
inline

◆ BSSimpleList() [2/3]

template<class T >
RE::BSSimpleList< T >::BSSimpleList ( const BSSimpleList< T > &  a_rhs)
inline

◆ BSSimpleList() [3/3]

template<class T >
RE::BSSimpleList< T >::BSSimpleList ( BSSimpleList< T > &&  a_rhs)
inline

◆ ~BSSimpleList()

template<class T >
RE::BSSimpleList< T >::~BSSimpleList ( )
inline

Member Function Documentation

◆ alloc_copies()

template<class T >
std::pair<Node*, Node*> RE::BSSimpleList< T >::alloc_copies ( size_type  a_count,
const_reference  a_value 
)
inlineprotected

◆ begin() [1/2]

template<class T >
iterator RE::BSSimpleList< T >::begin ( )
inline

◆ begin() [2/2]

template<class T >
const_iterator RE::BSSimpleList< T >::begin ( ) const
inline

◆ cbegin()

template<class T >
const_iterator RE::BSSimpleList< T >::cbegin ( ) const
inline

◆ cend()

template<class T >
constexpr const_iterator RE::BSSimpleList< T >::cend ( ) const
inlineconstexprnoexcept

◆ clear()

template<class T >
void RE::BSSimpleList< T >::clear ( )
inline

◆ copy_from()

template<class T >
void RE::BSSimpleList< T >::copy_from ( const BSSimpleList< T > &  a_rhs)
inlineprotected

◆ emplace_front()

template<class T >
template<class... Args>
reference RE::BSSimpleList< T >::emplace_front ( Args &&...  a_args)
inline

◆ emplace_front_impl()

template<class T >
template<class... Args>
void RE::BSSimpleList< T >::emplace_front_impl ( Args &&...  a_args)
inlineprotected

◆ empty()

template<class T >
bool RE::BSSimpleList< T >::empty ( ) const
inline

◆ end() [1/2]

template<class T >
constexpr const_iterator RE::BSSimpleList< T >::end ( ) const
inlineconstexprnoexcept

◆ end() [2/2]

template<class T >
constexpr iterator RE::BSSimpleList< T >::end ( )
inlineconstexprnoexcept

◆ erase_after() [1/2]

template<class T >
iterator RE::BSSimpleList< T >::erase_after ( const_iterator  a_first,
const_iterator  a_last 
)
inline

◆ erase_after() [2/2]

template<class T >
iterator RE::BSSimpleList< T >::erase_after ( const_iterator  a_pos)
inline

◆ erase_after_impl()

template<class T >
void RE::BSSimpleList< T >::erase_after_impl ( Node *  a_head,
Node *  a_tail 
)
inlineprotected

◆ front() [1/2]

template<class T >
reference RE::BSSimpleList< T >::front ( )
inline

◆ front() [2/2]

template<class T >
const_reference RE::BSSimpleList< T >::front ( ) const
inline

◆ get_head() [1/2]

template<class T >
constexpr const Node* RE::BSSimpleList< T >::get_head ( ) const
inlineconstexprprotectednoexcept

◆ get_head() [2/2]

template<class T >
constexpr Node* RE::BSSimpleList< T >::get_head ( )
inlineconstexprprotectednoexcept

◆ insert_after() [1/3]

template<class T >
iterator RE::BSSimpleList< T >::insert_after ( const_iterator  a_pos,
const_reference  a_value 
)
inline

◆ insert_after() [2/3]

template<class T >
iterator RE::BSSimpleList< T >::insert_after ( const_iterator  a_pos,
size_type  a_count,
const_reference  a_value 
)
inline

◆ insert_after() [3/3]

template<class T >
iterator RE::BSSimpleList< T >::insert_after ( const_iterator  a_pos,
value_type &&  a_value 
)
inline

◆ insert_after_impl()

template<class T >
Node* RE::BSSimpleList< T >::insert_after_impl ( Node *  a_pos,
std::pair< Node *, Node * >  a_values 
)
inlineprotected

◆ operator=() [1/2]

template<class T >
BSSimpleList& RE::BSSimpleList< T >::operator= ( BSSimpleList< T > &&  a_rhs)
inline

◆ operator=() [2/2]

template<class T >
BSSimpleList& RE::BSSimpleList< T >::operator= ( const BSSimpleList< T > &  a_rhs)
inline

◆ pop_front()

template<class T >
void RE::BSSimpleList< T >::pop_front ( )
inline

◆ push_front() [1/2]

template<class T >
void RE::BSSimpleList< T >::push_front ( const_reference  a_value)
inline

◆ push_front() [2/2]

template<class T >
void RE::BSSimpleList< T >::push_front ( value_type &&  a_value)
inline

◆ resize() [1/2]

template<class T >
void RE::BSSimpleList< T >::resize ( size_type  a_count)
inline

◆ resize() [2/2]

template<class T >
void RE::BSSimpleList< T >::resize ( size_type  a_count,
const value_type &  a_value 
)
inline

◆ resize_impl()

template<class T >
void RE::BSSimpleList< T >::resize_impl ( size_type  a_count,
const_reference  a_value 
)
inlineprotected

◆ TES_HEAP_REDEFINE_NEW()

template<class T >
RE::BSSimpleList< T >::TES_HEAP_REDEFINE_NEW ( )

Member Data Documentation

◆ _listHead

template<class T >
Node RE::BSSimpleList< T >::_listHead
protected
The documentation for this class was generated from the following file: