CommonLibSSE (Parapets fork)
Public Types | Public Member Functions | List of all members
RE::BSTArray< T, Allocator > Class Template Reference

#include <BSTArray.h>

Inheritance diagram for RE::BSTArray< T, Allocator >:
RE::BSTArrayHeapAllocator RE::BSTArrayBase

Public Types

using allocator_type = Allocator
 
using size_type = typename BSTArrayBase::size_type
 
using value_type = T
 
using pointer = value_type *
 
using const_pointer = const value_type *
 
using reference = value_type &
 
using const_reference = const value_type &
 
using iterator = pointer
 
using const_iterator = const_pointer
 
- Public Types inherited from RE::BSTArrayHeapAllocator
using size_type = std::uint32_t
 
- Public Types inherited from RE::BSTArrayBase
using size_type = std::uint32_t
 

Public Member Functions

 BSTArray ()=default
 
 BSTArray (const BSTArray &a_rhs)
 
 BSTArray (BSTArray &&)=default
 
 BSTArray (size_type a_count)
 
 ~BSTArray ()
 
BSTArray & operator= (const BSTArray &a_rhs)
 
BSTArray & operator= (BSTArray &&a_rhs)
 
 TES_HEAP_REDEFINE_NEW ()
 
constexpr reference operator[] (size_type a_pos) noexcept
 
constexpr const_reference operator[] (size_type a_pos) const noexcept
 
constexpr reference front () noexcept
 
constexpr const_reference front () const noexcept
 
constexpr reference back () noexcept
 
constexpr const_reference back () const noexcept
 
constexpr pointer data () noexcept
 
constexpr const_pointer data () const noexcept
 
constexpr iterator begin () noexcept
 
constexpr const_iterator begin () const noexcept
 
constexpr const_iterator cbegin () const noexcept
 
constexpr iterator end () noexcept
 
constexpr const_iterator end () const noexcept
 
constexpr const_iterator cend () const noexcept
 
constexpr bool empty () const noexcept
 
constexpr size_type size () const noexcept
 
void reserve (size_type a_newCap)
 
constexpr size_type capacity () const noexcept
 
void shrink_to_fit ()
 
void clear ()
 
iterator insert (const_iterator a_pos, const T &a_value)
 
iterator insert (const_iterator a_pos, T &&a_value)
 
template<class... Args>
iterator emplace (const_iterator a_pos, Args &&... a_args)
 
iterator erase (const_iterator a_pos)
 
void push_back (const value_type &a_value)
 
void push_back (value_type &&a_value)
 
template<class... Args>
reference emplace_back (Args &&... a_args)
 
void pop_back ()
 
void resize (size_type a_count)
 
void resize (size_type a_count, const value_type &a_value)
 
- Public Member Functions inherited from RE::BSTArrayHeapAllocator
constexpr BSTArrayHeapAllocator () noexcept=default
 
 BSTArrayHeapAllocator (const BSTArrayHeapAllocator &a_rhs)
 
constexpr BSTArrayHeapAllocator (BSTArrayHeapAllocator &&a_rhs) noexcept
 
 ~BSTArrayHeapAllocator ()
 
BSTArrayHeapAllocator & operator= (const BSTArrayHeapAllocator &a_rhs)
 
BSTArrayHeapAllocator & operator= (BSTArrayHeapAllocator &&a_rhs)
 
 TES_HEAP_REDEFINE_NEW ()
 
constexpr void * data () noexcept
 
constexpr const void * data () const noexcept
 
constexpr size_type capacity () const noexcept
 
- Public Member Functions inherited from RE::BSTArrayBase
constexpr BSTArrayBase () noexcept=default
 
constexpr BSTArrayBase (const BSTArrayBase &) noexcept=default
 
constexpr BSTArrayBase (BSTArrayBase &&) noexcept=default
 
 ~BSTArrayBase () noexcept
 
BSTArrayBase & operator= (const BSTArrayBase &) noexcept=default
 
BSTArrayBase & operator= (BSTArrayBase &&) noexcept=default
 
constexpr bool empty () const noexcept
 
constexpr size_type size () const noexcept
 

Additional Inherited Members

- Protected Member Functions inherited from RE::BSTArrayHeapAllocator
void * allocate (std::size_t a_size)
 
void deallocate (void *a_ptr)
 
constexpr void set_allocator_traits (void *a_data, std::uint32_t a_capacity, std::size_t) noexcept
 
- Protected Member Functions inherited from RE::BSTArrayBase
constexpr void set_size (size_type a_size) noexcept
 

Member Typedef Documentation

◆ allocator_type

template<class T , class Allocator = BSTArrayHeapAllocator>
using RE::BSTArray< T, Allocator >::allocator_type = Allocator

◆ const_iterator

template<class T , class Allocator = BSTArrayHeapAllocator>
using RE::BSTArray< T, Allocator >::const_iterator = const_pointer

◆ const_pointer

template<class T , class Allocator = BSTArrayHeapAllocator>
using RE::BSTArray< T, Allocator >::const_pointer = const value_type*

◆ const_reference

template<class T , class Allocator = BSTArrayHeapAllocator>
using RE::BSTArray< T, Allocator >::const_reference = const value_type&

◆ iterator

template<class T , class Allocator = BSTArrayHeapAllocator>
using RE::BSTArray< T, Allocator >::iterator = pointer

◆ pointer

template<class T , class Allocator = BSTArrayHeapAllocator>
using RE::BSTArray< T, Allocator >::pointer = value_type*

◆ reference

template<class T , class Allocator = BSTArrayHeapAllocator>
using RE::BSTArray< T, Allocator >::reference = value_type&

◆ size_type

template<class T , class Allocator = BSTArrayHeapAllocator>
using RE::BSTArray< T, Allocator >::size_type = typename BSTArrayBase::size_type

◆ value_type

template<class T , class Allocator = BSTArrayHeapAllocator>
using RE::BSTArray< T, Allocator >::value_type = T

Constructor & Destructor Documentation

◆ BSTArray() [1/4]

template<class T , class Allocator = BSTArrayHeapAllocator>
RE::BSTArray< T, Allocator >::BSTArray ( )
default

◆ BSTArray() [2/4]

template<class T , class Allocator = BSTArrayHeapAllocator>
RE::BSTArray< T, Allocator >::BSTArray ( const BSTArray< T, Allocator > &  a_rhs)
inline

◆ BSTArray() [3/4]

template<class T , class Allocator = BSTArrayHeapAllocator>
RE::BSTArray< T, Allocator >::BSTArray ( BSTArray< T, Allocator > &&  )
default

◆ BSTArray() [4/4]

template<class T , class Allocator = BSTArrayHeapAllocator>
RE::BSTArray< T, Allocator >::BSTArray ( size_type  a_count)
inlineexplicit

◆ ~BSTArray()

template<class T , class Allocator = BSTArrayHeapAllocator>
RE::BSTArray< T, Allocator >::~BSTArray ( )
inline

Member Function Documentation

◆ back() [1/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr const_reference RE::BSTArray< T, Allocator >::back ( ) const
inlineconstexprnoexcept

◆ back() [2/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr reference RE::BSTArray< T, Allocator >::back ( )
inlineconstexprnoexcept

◆ begin() [1/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr const_iterator RE::BSTArray< T, Allocator >::begin ( ) const
inlineconstexprnoexcept

◆ begin() [2/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr iterator RE::BSTArray< T, Allocator >::begin ( )
inlineconstexprnoexcept

◆ capacity()

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr size_type RE::BSTArray< T, Allocator >::capacity ( ) const
inlineconstexprnoexcept

◆ cbegin()

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr const_iterator RE::BSTArray< T, Allocator >::cbegin ( ) const
inlineconstexprnoexcept

◆ cend()

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr const_iterator RE::BSTArray< T, Allocator >::cend ( ) const
inlineconstexprnoexcept

◆ clear()

template<class T , class Allocator = BSTArrayHeapAllocator>
void RE::BSTArray< T, Allocator >::clear ( )
inline

◆ data() [1/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr const_pointer RE::BSTArray< T, Allocator >::data ( ) const
inlineconstexprnoexcept

◆ data() [2/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr pointer RE::BSTArray< T, Allocator >::data ( )
inlineconstexprnoexcept

◆ emplace()

template<class T , class Allocator = BSTArrayHeapAllocator>
template<class... Args>
iterator RE::BSTArray< T, Allocator >::emplace ( const_iterator  a_pos,
Args &&...  a_args 
)
inline

◆ emplace_back()

template<class T , class Allocator = BSTArrayHeapAllocator>
template<class... Args>
reference RE::BSTArray< T, Allocator >::emplace_back ( Args &&...  a_args)
inline

◆ empty()

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr bool RE::BSTArray< T, Allocator >::empty ( ) const
inlineconstexprnoexcept

◆ end() [1/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr const_iterator RE::BSTArray< T, Allocator >::end ( ) const
inlineconstexprnoexcept

◆ end() [2/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr iterator RE::BSTArray< T, Allocator >::end ( )
inlineconstexprnoexcept

◆ erase()

template<class T , class Allocator = BSTArrayHeapAllocator>
iterator RE::BSTArray< T, Allocator >::erase ( const_iterator  a_pos)
inline

◆ front() [1/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr const_reference RE::BSTArray< T, Allocator >::front ( ) const
inlineconstexprnoexcept

◆ front() [2/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr reference RE::BSTArray< T, Allocator >::front ( )
inlineconstexprnoexcept

◆ insert() [1/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
iterator RE::BSTArray< T, Allocator >::insert ( const_iterator  a_pos,
const T &  a_value 
)
inline

◆ insert() [2/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
iterator RE::BSTArray< T, Allocator >::insert ( const_iterator  a_pos,
T &&  a_value 
)
inline

◆ operator=() [1/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
BSTArray& RE::BSTArray< T, Allocator >::operator= ( BSTArray< T, Allocator > &&  a_rhs)
inline

◆ operator=() [2/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
BSTArray& RE::BSTArray< T, Allocator >::operator= ( const BSTArray< T, Allocator > &  a_rhs)
inline

◆ operator[]() [1/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr const_reference RE::BSTArray< T, Allocator >::operator[] ( size_type  a_pos) const
inlineconstexprnoexcept

◆ operator[]() [2/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr reference RE::BSTArray< T, Allocator >::operator[] ( size_type  a_pos)
inlineconstexprnoexcept

◆ pop_back()

template<class T , class Allocator = BSTArrayHeapAllocator>
void RE::BSTArray< T, Allocator >::pop_back ( )
inline

◆ push_back() [1/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
void RE::BSTArray< T, Allocator >::push_back ( const value_type &  a_value)
inline

◆ push_back() [2/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
void RE::BSTArray< T, Allocator >::push_back ( value_type &&  a_value)
inline

◆ reserve()

template<class T , class Allocator = BSTArrayHeapAllocator>
void RE::BSTArray< T, Allocator >::reserve ( size_type  a_newCap)
inline

◆ resize() [1/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
void RE::BSTArray< T, Allocator >::resize ( size_type  a_count)
inline

◆ resize() [2/2]

template<class T , class Allocator = BSTArrayHeapAllocator>
void RE::BSTArray< T, Allocator >::resize ( size_type  a_count,
const value_type &  a_value 
)
inline

◆ shrink_to_fit()

template<class T , class Allocator = BSTArrayHeapAllocator>
void RE::BSTArray< T, Allocator >::shrink_to_fit ( )
inline

◆ size()

template<class T , class Allocator = BSTArrayHeapAllocator>
constexpr size_type RE::BSTArray< T, Allocator >::size ( ) const
inlineconstexprnoexcept

◆ TES_HEAP_REDEFINE_NEW()

template<class T , class Allocator = BSTArrayHeapAllocator>
RE::BSTArray< T, Allocator >::TES_HEAP_REDEFINE_NEW ( )
The documentation for this class was generated from the following file: